超詳細整合SSM框架--（Spring + Spring MVC + MyBatis）
2023-07-16 21:00:50
超詳細整合SSM框架--（Spring + Spring MVC + MyBatis）
閱讀該文章之前首先要清楚Spring框架，SpringMVC框架，Mybatis框架。
SSM框架，是Spring + Spring MVC + MyBatis的縮寫，這個是繼SSH之後，目前比較主流的Java EE企業級框架，適用於搭建各種大型的企業級應用系統。
SpringMVC框架:
MVC簡介
MVC 全名是 Model View Controller，是模型(model)－檢視(view)－控制器(controller)的縮寫， 是一種用於設計建立 Web 應用程式表現層的模式。
Model（模型）： 通常指的就是我們的資料模型。作用一般情況下用於封裝資料。
View（檢視）： 通常指的就是我們的 jsp 或者 html。作用一般就是展示資料的。 通常檢視是依據模型資料建立的。
Controller（控制器）： 是應用程式中處理使用者互動的部分。作用一般就是處理程式邏輯的。
SpringMVC 是一種基於 Java 的實現 MVC 設計模型的請求驅動型別的輕量級 Web 框架，屬於 Spring FrameWork 的後續產品，已經融合在 Spring Web Flow 裡面。Spring 框架提供了構建 Web
應用程式的全功能 MVC 模組。使用 Spring 可插入的 MVC 架構，從而在使用 Spring 進行 WEB 開發時，可以選擇使用 Spring 的 Spring MVC 框架或整合其他 MVC 開發框架。
SpringMVC 已經成為目前最主流的 MVC 框架之一，並且隨著 Spring3.0 的釋出，已成為最優秀的 MVC 框架。
SpringMVC中的常用註解
@GetMapping
作用：用於建立請求URL和處理請求方法之間的對應關係
可以出現在類上，請求URL的第一級存取目錄
可以出現在方法上，請求URL的第二級存取目錄
value：用於指定請求的URL。它和path屬性的作用是一樣的
method：用於指定請求的方式
params：用於指定限制請求引數的條件
"""
@Controller
//@RequestMapping("SpringMVC/")
public class HelloController {
//請求方法為get 請求引數必須有username
@RequestMapping(value = "/hello",method = RequestMethod.GET,params = {"username"})
//@RequestMapping("/hello")
public String sayHello(){
System.out.println("SpringMVC hello~~~");
return "success";
}
}
"""
@RequestParam
作用：把請求中指定名稱的引數給控制器中的形參賦值
value：請求引數的名稱
required：請求引數中必須提供此引數。預設值：true，表示必須提供，如果不提供就報錯。
"""
@RequestMapping("/testRequestParam")
//RequestParam --更名
// 屬性 value=別名 required=必須含有的引數
public String testRequestParam(@RequestParam(value = "username") String name){
System.out.printf(name);
System.out.println("testRequestParam執行了~~~");
return "success";
}
"""
@RequestBody
作用：用於獲取請求體內容。直接使用得到key=value&key=vaule...結構的資料。get請求方式不適用
required：是否必須有請求體。當取值為true時，get請求會報錯。如果取值為false，get請求得到是null
"""
@RequestMapping("/testRequestBody")
//RequestBody 獲取請求體中的內容 如：username=benshan&password=98989&money=200
public String testRequestBody(@RequestBody String body){
System.out.println("testRequestBody執行了~~~");
System.out.println(body);
return "success";
}
"""
@PathVariable
作用：用於繫結URL中的預留位置。url中有/delete/{id},{id}就是預留位置。
"""
@RequestMapping("/testPathVariable/{id}")
//PathVariable使用Restful風格，結構清晰，拓展方便
public String testPathVariable(@PathVariable(value = "id") String id){
System.out.println("testPathVariable~~~");
System.out.println(id);
return "success";
}
"""
@RequestHeader
作用：用於獲取請求訊息頭
value 提供訊息頭名稱
required：是否必須有此訊息頭
"""
@RequestMapping("/testRequestHeader")
//testRequestHeader獲取請求頭的值
public String testRequestHeader(@RequestHeader(value = "Accept") String header){
System.out.println("testRequestHeader~~~");
System.out.println(header);
return "success";
}
"""
@CookieValue
作用：用於把指定cookie名稱的值傳入控制器方法引數
value：指定cookie的名稱
required：是否必須有此cookie
"""
@RequestMapping("/testCookieValue")
//testRequestHeader獲取請求頭的值
public String testCookieValue(@CookieValue(value = "JSESSIONID") String cookie){
System.out.println("testCookieValue~~~");
System.out.println(cookie);
return "success";
}
"""
@ModelAttribute
作用：可以修飾方法和引數。出現在方法上，表示當前方法會在控制器的方法執行之前執行，先執行。出現在引數上，獲取指定的資料給引數賦值
value 用於獲取資料的key
"""
@RequestMapping("/testModelAttribute")
public String testModelAttribute(){
System.out.println("testModelAttribute~~~");
return "success";
}
@ModelAttribute
//在控制器執行之前 執行
public void showUser(){
System.out.println("showUser執行了~~~");
}
"""
@SessionAttributes
作用：用於多次執行控制器方法間的引數共用
value 用於指定存入的屬性名稱
type：用於指定存入的資料型別
新註解
@RequestMapping 和 @GetMapping @PostMapping 區別
@GetMapping是一個組合註解，是@RequestMapping(method = RequestMethod.GET)的縮寫。
@PostMapping是一個組合註解，是@RequestMapping(method = RequestMethod.POST)的縮寫。
Spring框架
Spring是什麼？
Spring是一個輕量級Java開發框架，最早有Rod Johnson建立，目的是為了解決企業級應用開發的業務邏輯層和其他各層的耦合問題。它是一個分層的JavaSE/JavaEE full-stack（一站式）輕量級開源框架，為開發Java應用程式提供全面的基礎架構支援。Spring負責基礎架構，因此Java開發者可以專注於應用程式的開發。
體系結構
核心容器（Core Container）：Spring的核心容器是其他模組建立的基礎，有Spring-core、Spring-beans、Spring-context、Spring-context-support和Spring-expression（String表示式語言）等模組組成
資料存取/整合（Data Access）層：資料存取/整合層由JDBC、ORM、OXM、JMS和事務模組組成。
Web層：Web層由Spring-web、Spring-webmvc、Spring-websocket和Portlet模組組成。
AOP（Aspect Oriented Programming）模組：提供了一個符合AOP要求的面向切面的程式設計實現，允許定義方法攔截器和切入點，將程式碼按照功能進行分離，以便乾淨地解耦。
植入（Instrumentation）模組：提供了類植入（Instrumentation）支援和類載入器的實現，可以在特定的應用伺服器中使用。
訊息傳輸（Messaging）：Spring4.0以後新增了訊息（Spring-messaging）模組，該模組提供了對訊息傳遞體系結構和協定的支援。
測試（Test）模組：Spring-test模組支援使用JUnit或TestNG對Spring元件進行單元測試和整合測試。
引入jar包
"""
<dependencies>
<!--spring的jar包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.11.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.0.11.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.0.11.RELEASE</version>
</dependency>
</dependencies>
"""
匯入約束
"""
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!--spring的約束 -->
<!--把物件的建立交給Spring來管理 -->
<!--獲取容器中物件時使用id-->
<!-- <bean id="accountServiceImpl" class="com.dynamic2.service.Impl.AccountServiceImpl"></bean>
<bean id="accountDaoImpl" class="com.dynamic2.dao.Impl.AccountDaoImpl"></bean>-->
<context:component-scan base-package="com.dynamic2"></context:component-scan>
</beans>
"""
常見註解
用於建立物件
@Component：把資源讓spring來管理。相當於xml中設定一個bean。value：指定bean的id，如果不指定value屬性，預設bean的id是當前類的類名。首字母小寫
@Controller：與@Component功能一樣，一般用在表現層，便於分層
@Service：與@Component功能一樣，一般用在業務層，便於分層
@Repository：與@Component功能一樣，一般用於持久層，便於分層
"""
/**
* @Author: Promsing
* @Date: @Date: 2023/7/17 - 11:34
* @Description: 用於建立物件
* @version： 1.0
* XML設定 <bean id="accountServiceImpl" class="com.dynamic2.service.Impl.AccountServiceImpl"></bean>
*/
@Repository("accountDao ")
public class AccountDaoImpl implements IAccountDao {
......
}
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
......
}
@Component("accountServiceImpl")
@Scope("prototype")//多例
public class AccountServiceImpl2 implements IAccountService {
......
}
"""
用於注入資料
@Autowired：自動按照型別注入。當使用註解注入屬性時，set方法可以省略。它只能注入其他bean型別。當有多個型別匹配時。使用要注入的物件變數名稱作為bean的id，在spring容器中查詢，找到了注入成功，找不到就報錯。
@Qualifier：在自動按照型別注入的基礎上，再按照Bean的id注入。它在給欄位注入時不能單獨使用，必須和@Autowire一起使用；但是給方法引數注入時，可以單獨使用。value屬性是指定Bean的id
@Resource：直接按照Bean的id注入。它也只能注入其他Bean型別。name屬性是指定Bean的id
@Value：注入基本資料型別和String型別資料
"""
/**
* @Author: Promsing
* @Date: @Date: 2023/7/17 - 11:34
* @Description: 用於建立物件
* @version： 1.0
* XML設定 <bean id="accountServiceImpl" class="com.dynamic2.service.Impl.AccountServiceImpl"></bean>
*/
@Component("accountServiceImpl")
@Scope("prototype")//多例
public class AccountServiceImpl implements IAccountService {
//注入成員變數
/* @Autowired 自動按照型別注入--尋找型別
@Qualifier("accountDao2")*/ //尋找id
//以上兩個註解相加的作用等於這個
@Resource(name = "accountDao2")
private IAccountDao accountDao2;
@Override
public void saveAccount() {
accountDao2.saveAccount();
//System.out.println("service中的saveAccount執行了~~");
}
}
"""
用於改變作用範圍
@Scope：指定Bean的作用範圍。value屬性指定範圍的值--singleton單例，prototype多例，request作用與web應用的請求範圍，session作用與web應用的對談範圍，global-session作用與叢集環境中對談範圍
"""
@Component("accountServiceImpl")
@Scope("prototype")//多例
public class AccountServiceImpl implements IAccountService {
......
}
"""
和生命週期相關(瞭解)
@PostConstruct：用於指定初始化方法
@PreDestroy：用於指定銷燬方法
Spring5
@Configuration：用於指定當前類是一個spring設定類，當有容器時會從該類上載入註解。獲取容器是使用AnnotationApplicationContext（有@Configuration註解的類.class）
@ComponentScan：用於指定spring在初始化容器時要掃描的包。作用和在spring的xml組態檔找那個的
@Bean：該註解只用用在方法上，表明使用此方法建立一個物件，並且放入spring容器中
@Import：用於匯入其他設定類，解耦合
"""
/**
* @Author: Promsing
* @Date: @Date: 2023/7/17 - 0:36
* @Description: Spring設定類
* @version： 1.0
*/
@Configuration//指定當前類是一個設定類
@ComponentScan("com.dynamic_transaction_anno")//用於指定spring在初始化容器時需要掃描的包
@Import({JdbcConfig.class,TransactionConfig.class})//匯入其他設定類
@EnableTransactionManagement//開啟spring註解事務的支援
public class SpringConfig {
@Bean("jdbcTemplate")
public JdbcTemplate createJdbcTemplate(DataSource ds){
return new JdbcTemplate(ds);
}
@Bean("dataSource")
public DataSource createDataSource(){
DriverManagerDataSource dr=new DriverManagerDataSource();
dr.setDriverClassName("com.mysql.jdbc.Driver");//com.mysql.jdbc.Driver
dr.setUrl("jdbc:mysql//localhost:330b/eesy");
dr.setUsername("root");
dr.setPassword("root");
return dr;
}
}
"""
Spring整合Junit
@RunWith：替代原有的執行器
@ContextConfiguration：指定組態檔的位置
"""
@RunWith(SpringJUnit4ClassRunner.class)//替代原有執行器
@ContextConfiguration(classes=SpringConfiguration.class)//指定設定類
public class AccountServiceTest {
@Test
public void testFindAll(){
//執行測試方法
}
}
"""
從IOC容器中獲取物件
"""
/**
* @Author: Promsing
* @Date:@Date: 2023/7/17 - 11:22
* @Description: 單元測試
* @version： 1.0
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=SpringConfiguration.class)
public class AccountServiceTest {
@Resource(name = "accountServiceImpl")
private IAccountService accountService;
@Test
//從容器中獲取物件
public void test(){
//一、獲取容器
//使用組態檔載入
ApplicationContext ac=new ClassPathXmlApplicationContext("bean3_1.xml");
//使用設定類載入
/// ApplicationContext ac=new AnnotationConfigApplicationContext(SpringConfiguration.class);
//二、獲取物件
accountService=(IAccountService)ac.getBean("accountServiceImpl",IAccountService.class);
//三、執行方法
List<Account> allAccounts = accountService.findAllAccount();
for (Account allAccount : allAccounts) {
System.out.println(allAccount);
}
}
}
"""
Mybatis框架
MyBatis 是一款優秀的持久層框架，它支援自定義 SQL、儲存過程以及高階對映。MyBatis 免除了幾乎所有的 JDBC 程式碼以及設定引數和獲取結果集的工作。MyBatis 可以通過簡單的 XML 或註解來設定和對映原始型別、介面和 Java POJO（Plain Old Java Objects，普通老式 Java 物件）為資料庫中的記錄。
Mybatis簡介
官網連結：https://mybatis.org/mybatis-3/zh/index.html。
更加詳細的資訊可以去官網檢視。
MyBatis 是一款優秀的持久層框架，它支援自定義 SQL、儲存過程以及高階對映。MyBatis 免除了幾乎所有的 JDBC 程式碼以及設定引數和獲取結果集的工作。MyBatis 可以通過簡單的 XML 或註解來設定和對映原始型別、介面和 Java POJO（Plain Old Java Objects，普通老式 Java 物件）為資料庫中的記錄。
要使用 MyBatis， 只需將 mybatis-x.x.x.jar 檔案置於類路徑（classpath）中即可。
如果使用 Maven 來構建專案，則需將下面的依賴程式碼置於 pom.xml 檔案中：
"""
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>x.x.x</version>
</dependency>
"""
設定步驟
1.引入Mybatis的jar包
2.編寫實體類與DAO介面
3.新增主組態檔（設定mysql環境，事務型別，資料來源，連線資料庫的基本資訊，對映檔案的位置）
4.新增DAO介面的對映檔案（需要指明DAO介面的位置，為每個方法做一個對映）注：所在路徑在Resource資料夾下，目錄路徑需要DAO的層次結構一樣
5.使用mybatis框架
使用步驟（所有的xml設定已設定完畢）
1.讀取組態檔，可使用mybatis封裝的Resources類。
2.建立SQLSessionFactory工廠
3.使用工廠生產SQLsession物件
4.使用SQLSession建立DAO介面的代理物件
5.使用代理物件執行方法
6.提交事務，釋放資源
基礎資料
實體類
"""
public class User implements Serializable {
/**
* Java實體類為什麼要實現Serializable介面
* 1.用於序列化與反序列化--一個類只有實現了Serializable介面，它的物件才能被序列化。
* 2.Serializable介面就是Java提供用來進行高效率的異地共用範例物件的機制，實現這個介面即可。
*/
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", birthday=" + birthday +
", sex='" + sex + '\'' +
", address='" + address + '\'' +
'}';
}
"""
DAO層的介面
"""
public interface IUserDao {
/**
* 查詢所有
* @return 所有的User資訊
*/
//@Select("select * from User")
List<User> findAll();
/**
* 儲存操作
* @param user
*/
//@Insert("insert into User(username,address,sex,birthday)values()")
void saveUser(User user);
/**
* 更改操作
*/
void updateUser(User user);
/**
* 刪除操作
* @param i
*/
void deleteUser(Integer i);
/**
* 根據id查詢單個使用者
* @param id
* @return
*/
User findById(Integer id);
/**
* 根據名稱模糊查詢
* @param name
* @return
*/
List<User> findByName(String name);
/**
* 查詢總使用者數
* @return
*/
int findTotal();
}
"""
主組態檔
"""
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--myBatis的主組態檔 -->
<configuration>
<!--設定環境-->
<environments default="mysql">
<!--設定mysql環境-->
<environment id="mysql">
<!--設定事務的型別-->
<transactionManager type="JDBC"></transactionManager>
<!--設定資料來源（連線池）-->
<dataSource type="POOLED">
<!--設定連線資料庫的基本資訊-->
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/eesy"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<!--對映檔案 組態檔方式-->
<mappers>
<mapper resource="com/dynamic_basics/dao/IUserDao.xml"></mapper>
</mappers>
<!--對映檔案 註解方式(使用註解就要刪除源組態檔)-->
<!-- <mappers>
<mapper class="com.dynamic_basics.dao.IUserDao"></mapper>
</mappers>-->
</configuration>
"""
子組態檔
"""
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dynamic_basics.dao.IUserDao">
<!--使用設定的方式解決Java實體類與資料庫列名不一致的問題-->
<resultMap id="userMap" type="com.dynamic_basics.domain.User">
<!--主鍵欄位-->
<id property="userId" column="id"></id>
<!--非主鍵欄位-->
<result property="userName" column="username"></result>
<result property="userAddress" column="address"></result>
<result property="userSex" column="sex"></result>
<result property="userBirthday" column="birthday"></result>
</resultMap>
<!--查詢所有 id使用方法名-->
<select id="findAl l" resultType="com.dynamic_basics.domain.User" resultMap="userMap">
select * from user
</select>
<!--儲存使用者-->
<insert id="saveUser" parameterType="com.dynamic_basics.domain.User">
<!--引數使用了ognl表示式-->
insert into user(username,address,sex,birthday)values(#{username},#{address},#{sex},#{birthday});
</insert>
<!--更新使用者-->
<insert id="updateUser" parameterType="com.dynamic_basics.domain.User">
update user set username=#{username},address=#{address},sex=#{sex},birthday=#{birthday} where id=#{id}
</insert>
<!--刪除使用者-->
<delete id="deleteUser" parameterType="int">
delete from User where id=#{id}
</delete>
<!--根據id查詢使用者-->
<select id="findById" parameterType="int" resultType="com.dynamic_basics.domain.User">
select * from user where id=#{id}
</select>
<!--根據名稱模糊查詢-->
<select id="findByName" resultType="com.dynamic_basics.domain.User" parameterType="String">
select * from user where username like #{name}
</select>
<!--獲取使用者的總記錄數-->
<select id="findTotal" resultType="int">
SELECT COUNT(id) FROM `user`;
</select>
</mapper>
"""
測試類
"""
/**
* @Author: Promsing
* @Date: @Date: 2023/7/17 - 8:58
* @Description: 描述 形容
* @version： 1.0
*/
public class MyBatisTest {
private InputStream in;
private SqlSession sqlSession;
private IUserDao userDao;
@Before
public void init()throws Exception{
//1.讀取組態檔 Resources是myBatis封裝的類
in= Resources.getResourceAsStream("SqlMapConfig.xml");
//2.建立SQLSessionFactory工廠
// SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(is);
SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
SqlSessionFactory factory=builder.build(in);
//3.使用工廠生產SQLSession物件
sqlSession = factory.openSession();
//4.使用SQLSession建立DAO介面的代理物件
userDao = sqlSession.getMapper(IUserDao.class);
}
@After
public void destory()throws Exception{
//6.釋放資源
//提交事務
sqlSession.commit();
sqlSession.close();
in.close();
}
//入門案例
/**
* 查詢操作
*/
@Test
public void selectUser(){
//初始化資源-使用註解Before
//5.使用代理物件執行方法
List<User> all = userDao.findAll();
for (User user : all) {
System.out.println(user);
}
//釋放資源-使用註解After
}
/**
* 測試儲存
*/
@Test
public void testSave() {
User user=new User();
user.setUsername("mybatis");
user.setAddress("北京市延慶區");
user.setSex("女");
user.setBirthday(new Date());
//初始化資源-使用註解Before
//5.使用代理物件執行方法
userDao.saveUser(user);
//釋放資源-使用註解After
}
/**
* 測試修改
*/
@Test
public void testUpdate() {
User user=new User();
user.setId(50);
user.setUsername("mybatis_plus");
user.setAddress("北京市安次");
user.setSex("男");
user.setBirthday(new Date());
//初始化資源-使用註解Before
//5.使用代理物件執行方法
userDao.updateUser(user);
//釋放資源-使用註解After
}
/**
* 測試刪除
*/
@Test
public void testDelete() {
//初始化資源-使用註解Before
//5.使用代理物件執行方法
userDao.deleteUser(50);
//釋放資源-使用註解After
}
/**
* 查詢單個人員資訊
*/
@Test
public void testFindById() {
//初始化資源-使用註解Before
//5.使用代理物件執行方法
User user=userDao.findById(49);
System.out.println(user);
//釋放資源-使用註解After
}
/**
* 模糊查詢
*/
@Test
public void testFindByName() {
//初始化資源-使用註解Before
//5.使用代理物件執行方法
List<User> users=userDao.findByName("%王%");
users.forEach(i-> System.out.println(i));
//釋放資源-使用註解After
}
/**
* 測試查詢總記錄條數
*/
@Test
public void testFindTotal() {
//初始化資源-使用註解Before
//5.使用代理物件執行方法
int total=userDao.findTotal();
System.out.println(total);
//釋放資源-使用註解After
}
}
"""
總結
Mybatis其實使用的方法很簡單，需要多記住一些設定，當設定做好了，使用的時候很簡單。Mybatis框架將JDBC中複雜的註冊驅動、獲取連線，使用不同的服務類---
（DriverManager,Connection,Statement,ResultSet）都封裝了。其實框架的學習就是了解框架、熟悉設定，使用框架的階段。
設定頂層結構：
常用標籤設定
具體設定的詳解請去mybatis官網
整合思路
1.先搭建整合的環境
2.把Spring的設定搭建完成
3.再使用Spring整合SpringMVC框架
4.最後使用Spring整合Mybatis框架
設計資料庫
"""
CREATE DATABASE ssm;
USE ssm;
CREATE TABLE account ( id INT PRIMARY KEY auto_increment, NAME VARCHAR ( 20 ), money DOUBLE );
"""
搭建環境，選擇maven工程，選擇骨架webapp
匯入依賴
"""
<name>SSM Maven Webapp</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
<!-- 版本鎖定-->
<spring.version>5.0.2.RELEASE</spring.version>
<slf4j.version>1.6.6</slf4j.version>
<log4j.version>1.2.12</log4j.version>
<mysql.version>5.1.6</mysql.version>
<mybatis.version>3.4.5</mybatis.version>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!-- spring -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.8</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.0.2.RELEASE</version>
</dependency> <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.0.2.RELEASE</version>
</dependency> <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.0.2.RELEASE</version>
</dependency> <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency> <dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- log start -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency> <dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<!-- log end -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>${mybatis.version}</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
</dependencies>
"""
建立目錄結構，建立domain，controller，service，dao
web依賴於service，service依賴於dao，dao依賴於domain
domain
"""
package com.dynamic.domain;
import java.io.Serializable;
/**
* @Author: Promsing
* @Date: 2023/7/17 - 17:44
* @Description: 實體類-Account
* @version： 1.0
*/
public class Account implements Serializable {
private Integer id;
private String name;
private Double money;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
'}';
}
}
"""
Controller層
"""
package com.dynamic.controller;
/**
* @Author: Promsing
* @Date: 2023/7/17 - 17:50
* @Description: Web層賬戶
* @version： 1.0
*/
@Controller
@RequestMapping("/account")
public class AccountController {
@Autowired
private AccountService service;
//需要加 /
@GetMapping("/findAll")
public String findAll(Model model){
System.out.println("表現層查詢所有資訊！");
//呼叫Service方法
List<Account> all = service.findAll();
for (Account account : all) {
System.out.println(account);
}
model.addAttribute("all",all);
return "success";
}
@PostMapping("/save")
public String save(Account account){
service.saveAccount(account);
return "success";
}
}
"""
service層
"""
public interface AccountService {
/**
* 查詢所有
* @return
*/
public List<Account> findAll();
/**
* 儲存賬戶資訊
* @param account
*/
public void saveAccount(Account account);
}
@Service("accountService")
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao dao;
@Override
public List<Account> findAll() {
System.out.println("業務層：查詢所有資訊！");
return dao.findAll();
}
@Override
public void saveAccount(Account account) {
System.out.println("業務層：儲存賬戶。。。");
dao.saveAccount(account);
}
}
"""
dao層
"""
/**
* @Author: Promsing
* @Date: 2023/7/17 - 17:46
* @Description: DAO層 使用註解
* @version： 1.0
*/
@Repository
public interface AccountDao {
/**
* 查詢所有
* @return
*/
@Select("select * from account")
public List<Account> findAll();
/**
* 儲存賬戶資訊
* @param account
*/
@Insert("insert into account (name,money) values(#{name},#{money})")
public void saveAccount(Account account);
}
"""
index頁面
"""
<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2023/7/17
Time: 19:00
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>首頁</title>
</head>
<body>
<a href="account/findAll">測試查詢</a>
<form action="account/save" method="post">
姓名：<input type="text" name="name"><br/>
金額：<input type="text" name="money"><br/>
<input type="submit" value="儲存"><br/>
</form>
</body>
</html>
"""
Success頁面
"""
<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2023/7/17
Time: 19:10
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>成功頁面</title>
</head>
<body>
<h1>成功頁面</h1>
${all}
<br/>
<c:forEach items="${all}" var="account">
${account.name}
${account.money}
</c:forEach>
</body>
</html>
"""
編寫Spring框架
applicationContext檔案
"""
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 1.匯入約束
2.開啟註解掃描支援-->
<!-- 開啟註解的掃描-->
<context:component-scan base-package="com.dynamic">
<!-- 設定哪些註解不掃描，進行忽略-->
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
</beans>
"""
Spring整合SpringMVC框架
編寫SpringMVC框架
web.xml
"""
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<!-- 設定前端控制器-->
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 載入springmvc.xml組態檔-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- 啟動伺服器，建立該Servlet-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 解決中文亂碼的過濾器-->
<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
"""
Springmvc.xml
"""
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=" http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 開啟註解掃描 只掃描Controller註解-->
<context:component-scan base-package="com.dynamic">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!-- 設定檢視解析器物件 -->
<bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/pages/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
<!-- 過濾靜態資源-->
<!-- 設定靜態資源不過濾 -->
<mvc:resources location="/css/" mapping="/css/**" />
<mvc:resources location="/images/" mapping="/images/**" />
<mvc:resources location="/js/" mapping="/js/**" />
<!-- 開啟springMVC註解的支援-->
<mvc:annotation-driven></mvc:annotation-driven>
</beans>
"""
整合SpringMVC框架
在Controller中能夠成功呼叫service物件中的方法
在web.xml中設定ContextLoaderListener監聽器。載入applicationContext.xml檔案
在專案啟動的時候，就去載入applicationContext.xml的組態檔，在web.xml中設定ContextLoaderListener監聽器。（該監聽器只能載入WEB-INF目錄下的applicationContext.xml的組態檔）
"""
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<!-- 設定Spring的監聽器,預設只載入 WEB-INF目錄下的applicationContext.xml-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 設定組態檔的路徑-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<!-- 設定前端控制器-->
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 載入springmvc.xml組態檔-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!-- 啟動伺服器，建立該Servlet-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 解決中文亂碼的過濾器-->
<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
"""
Spring整合Mybatis框架
編寫Mybatis框架
在web專案中編寫SqlMapConfig.xml的組態檔，編寫核心組態檔（AccountDAO介面的方法上新增註解，編寫Sql語句）
"""
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 設定環境-->
<environments default="mysql">
<environment id="mysql">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///ssm"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<!-- 引入對映組態檔 resource-->
<!-- 使用的是註解 class -->
<mappers>
<!-- 該包下所有的dao介面都可以使用 -->
<package name="com.dynamic.dao"/>
</mappers>
</configuration>
"""
整合Mybatis框架
把SqlMapConfig.xml組態檔中的內容設定到applicationContext.xml組態檔中，同時設定Spring的宣告式事務管理
"""
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 1.匯入約束
2.開啟註解掃描支援-->
<!-- 開啟註解的掃描-->
<context:component-scan base-package="com.dynamic">
<!-- 設定哪些註解不掃描，進行忽略-->
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!-- spring整合Mybatis框架-->
<!-- 設定資料庫連線池-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql:///ssm"/>
<property name="user" value="root"/>
<property name="password" value="root"/>
</bean>
<!-- 設定sqlSessionFactory工廠-->
<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 設定AccountDAO介面所在的包-->
<bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.dynamic.dao"></property>
</bean>
<!-- 設定Spring框架宣告式事務管理-->
<!-- 設定事務管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--設定事務通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="find*" read-only="true"></tx:method>
<tx:method name="*" isolation="DEFAULT"></tx:method>
</tx:attributes>
</tx:advice>
<!-- 設定AOP增強-->
<aop:config>
<aop:advisor advice-ref="txAdvice" pointcut="execution(public * com.dynamic.service..ServiceImpl.*(..))"/>
</aop:config>
</beans>
"""