SSM框架學習筆記（持續更新....）最近更新：2019年11月17日

第一節課 第一個mybatis應用程序

1、新建一個java項目爲：mybatis_0921, 項目結構：

2、代碼
User.java

private String username,userid;   //懂我意思啊？

配置文件：mybatis-config.xml

<?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="development">
 		<environment id="development">
 			<!-- 數據庫的驅動管理類型 -->
 			<transactionManager type="JDBC" />
 			<!-- 配置數據源 -->
 			<dataSource type="POOLED">
 				<property name="url" value="jdbc:mysql://localhost:3306/user"/>
 				<property name="username" value="root"/>
 				<property name="password" value="caixibei"/>
 				<property name="driver" value="com.mysql.jdbc.Driver"/>
 			</dataSource>
 		</environment>
 	</environments>
 	
 	<!-- 配置映射文件 -->
 	<mappers>
 		<mapper resource="/src/mybatis-usermapper.xml" />
 	</mappers>
 </configuration>

配置文件:mybatis-usermapper.xml

<?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>
	<!-- 1、查詢用戶 -->
	<select id="queryUsers" resultType="my.entity.User">
		select * from userinfo;
	</select>
</mapper>

3、數據庫的創建

mysql> use user;
Database changed
mysql> select * from userinfo;
+----------+----------+
| username | userid   |
+----------+----------+
| wsz      | a123     |
| wsz      | a123     |
| wsz      | a123     |
| wsz      | a123     |
| wsz      | a123     |
| wsz      | a123     |
| wsz      | a123     |
| asda     | a1dasd23 |
| asda     | a1dasd23 |
| asda     | a1dasd23 |
| asda     | a1dasd23 |
+----------+----------+
11 rows in set (0.00 sec)
mysql>

4、然後編寫測試代碼:

1、實現所有用戶的查詢操作

package my.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import my.entity.User;
public class Test {
	public static void main(String[] args) throws IOException {
		//1、加載mybatis核心配置文件
		InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
		//2、通過核心配置文件創建會話工廠
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
		//3、通過會話工廠打開會話
		SqlSession sqlSession = sqlSessionFactory.openSession();
		//4、通過會話實現數據庫的查詢操作
			//*1--查詢所有學生
			queryUsers(sqlSession);
		
	}
	
	//查詢所有學生操作
	public static void queryUsers(SqlSession sqlSession) {
		List<User> list = sqlSession.selectList("userOperate.queryUsers");
		System.out.println("學生信息如下：");
		for(User user:list) {
			System.out.println(user);
		}
	}
}

5、效果

6、實現單個用戶的條件查詢
1)配置文件：mybatis-usermapper.xml

<?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="userOperate">
	<!-- 1、查詢用戶 -->
	<select id="queryUsers" resultType="my.entity.User">
		select * from userinfo;
	</select>
	<!-- 2、條件查詢用戶 -->
	<select id="queryUser" resultType="my.entity.User">
		select * from userinfo where userid=#{userid};
	</select>
</mapper>

2）測試代碼:Test.java

package my.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import my.entity.User;
public class Test {
	public static void main(String[] args) throws IOException {
		//1、加載mybatis核心配置文件
		InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
		//2、通過核心配置文件創建會話工廠
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
		//3、通過會話工廠打開會話
		SqlSession sqlSession = sqlSessionFactory.openSession();
		//4、通過會話實現數據庫的查詢操作
			//*1--查詢所有用戶
			queryUsers(sqlSession);
			//*2--條件查詢某個用戶
			queryUser(sqlSession);
	}
	
	//查詢所有學生操作
	public static void queryUsers(SqlSession sqlSession) {
		List<User> list = sqlSession.selectList("userOperate.queryUsers");
		System.out.println("學生信息如下：");
		for(User user:list) {
			System.out.println(user);
		}
	}
	
	//條件查詢用戶
	public static void queryUser(SqlSession sqlSession) {
		User user = sqlSession.selectOne("userOperate.queryUser","0000");
		System.out.println("查詢用戶id爲'0000'的用戶信息如下：");
		System.out.println(user);
	}
}

7、效果

8、根據條件刪除指定的用戶信息
1)測試代碼Test.java

package my.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import my.entity.User;
public class Test {
	public static void main(String[] args) throws IOException {
		//1、加載mybatis核心配置文件
		InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
		//2、通過核心配置文件創建會話工廠
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
		//3、通過會話工廠打開會話
		SqlSession sqlSession = sqlSessionFactory.openSession();
		//4、通過會話實現數據庫的查詢操作
			//*1--查詢所有用戶
			queryUsers(sqlSession);
			//*2--條件查詢某個用戶
			queryUser(sqlSession);
			//*3--根據id刪除用戶信息
			deleteUser(sqlSession);
		//5、提交事務：如果不提交，後臺數據庫並不會發生改變
		sqlSession.commit();
		//6、關閉事務
		sqlSession.close();
	}
	
	//查詢所有學生操作
	public static void queryUsers(SqlSession sqlSession) {
		List<User> list = sqlSession.selectList("userOperate.queryUsers");
		System.out.println("學生信息如下：");
		for(User user:list) {
			System.out.println(user);
		}
	}
	
	//條件查詢用戶
	public static void queryUser(SqlSession sqlSession) {
		User user = sqlSession.selectOne("userOperate.queryUser","0000");
		System.out.println("查詢用戶id爲'0000'的用戶信息如下：");
		System.out.println(user);
	}
	//刪除用戶信息
	public static void deleteUser(SqlSession sqlSession) {
		sqlSession.delete("userOperate.deleteUser","0000");
		System.out.println("刪除成功...");
	}
	
}

2）配置文件mybatis-usermapper.xml

<?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="userOperate">
	<!-- 1、查詢用戶 -->
	<select id="queryUsers" resultType="my.entity.User">
		select * from userinfo;
	</select>
	<!-- 2、條件查詢用戶 -->
	<select id="queryUser" resultType="my.entity.User">
		select * from userinfo where userid=#{userid};
	</select>
	<!-- 3、根據userid對指定的用戶進行信息的刪除 -->
	<delete id="deleteUser">
		delete from userinfo where userid=#{userid};
	</delete>
	
</mapper>

9、效果：

第二節課 使用接口註解實現數據庫的操作

1、新建一個java項目，項目結構如下：

2、數據庫，我們依舊使用上節課用的數據庫：user.sql

--表：userinfo  
--記錄如下：
mysql> use user;
Database changed
mysql> select * from userinfo;
+----------+----------+
| username | userid   |
+----------+----------+
| wsz      | a123     |
| wsz      | a123     |
| wsz      | a123     |
| wsz      | a123     |
| wsz      | a123     |
| wsz      | a123     |
| wsz      | a123     |
| asda     | a1dasd23 |
| asda     | a1dasd23 |
| asda     | a1dasd23 |
| asda     | a1dasd23 |
+----------+----------+
11 rows in set (0.00 sec)

3、代碼
核心配置文件：mybatis-config.xml

<?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="development">
 		<environment id="development">
 			<transactionManager type="JDBC" />
 			<dataSource type="POOLED">
 				<property name="url" value="jdbc:mysql://localhost:3306/user"/>
 				<property name="username" value="root"/>
 				<property name="password" value="caixibei"/>
 				<property name="driver" value="com.mysql.jdbc.Driver"/>
 			</dataSource>
 		</environment>
 	</environments>
 </configuration>

dao層數據庫持久化操作接口：UserDao.java
1）實現所有用戶的信息查詢操作

package my.dao;
import java.util.List;
import org.apache.ibatis.annotations.Select;
import my.entity.User;
public interface UserDao {
	//*--1、查詢所有用戶
	@Select("select * from userinfo")
	public List<User> queryUsers();
}

測試代碼: Test_01.java

package my.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;

import my.dao.UserDao;
import my.entity.User;
public class Test_01 {
	static UserDao userDao = null;
	static SqlSession sqlSession = null;
	@BeforeAll
	public static void getMapper() throws IOException {
		//--1)加載mybatis核心配置文件
		InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
		//--2)根據核心配置文件創建會話工廠並且添加映射
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
		sqlSessionFactory.getConfiguration().addMapper(UserDao.class);
		//--3)通過會話工廠獲取會話並得到接口
		sqlSession = sqlSessionFactory.openSession();
		userDao = sqlSession.getMapper(UserDao.class);
		//--4)操作數據庫
	}
	
	
	//*--1、查詢所有用戶信息
	@Test
	public void queryUsers() {
		List<User> list = userDao.queryUsers();
		for(User user:list) {
			System.out.println(user);
		}
	}
	//*--2、根據id修改某一個用戶的信息
	@Test
	public void updateUser() {
		userDao.updateUser("baby", "2017120107", "a123");
		System.out.println("修改成功...");
	}
	
	//提交併關閉事務
	@AfterAll
	public static void commit() {
		sqlSession.commit();
		sqlSession.close();
	}
}

效果

2）根據id修改某一個用戶的信息
測試代碼：Test_01.java

package my.dao;
import java.util.List;
import org.apache.ibatis.annotations.Select;
import my.entity.User;
public interface UserDao {
	//*--1、查詢所有用戶
	@Select("select * from userinfo")
	public List<User> queryUsers();
}

測試代碼: Test_01.java

package my.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;

import my.dao.UserDao;
import my.entity.User;
public class Test_01 {
	static UserDao userDao = null;
	static SqlSession sqlSession = null;
	@BeforeAll
	public static void getMapper() throws IOException {
		//--1)加載mybatis核心配置文件
		InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
		//--2)根據核心配置文件創建會話工廠並且添加映射
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
		sqlSessionFactory.getConfiguration().addMapper(UserDao.class);
		//--3)通過會話工廠獲取會話並得到接口
		sqlSession = sqlSessionFactory.openSession();
		userDao = sqlSession.getMapper(UserDao.class);
		//--4)操作數據庫
	}
	
	
	//*--1、查詢所有用戶信息
	@Test
	public void queryUsers() {
		List<User> list = userDao.queryUsers();
		for(User user:list) {
			System.out.println(user);
		}
	}
	//*--2、根據id修改某一個用戶的信息
	@Test
	public void updateUser() {
		userDao.updateUser("baby", "2017120107", "a123");
		System.out.println("修改成功...");
	}
	
	//提交併關閉事務
	@AfterAll
	public static void commit() {
		sqlSession.commit();
		sqlSession.close();
	}
}

dao層接口

package my.dao;
import java.util.List;

import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import my.entity.User;
public interface UserDao {
	//*--1、查詢所有用戶
	@Select("select * from userinfo")
	public List<User> queryUsers();
	
	//*--2、根據id修改某一個用戶的信息
	@Update("update userinfo set username=#{username},userid=#{newid} where userid=#{userid}")
	public  void updateUser(@Param("username")String username,@Param("newid")String newid,@Param("userid")String userid);
}

效果:

關於其他操作數據庫的方法，請自行編寫代碼測試…

第三節課 Mybatis表關聯（一對多）

1、首先我們需要兩個數據庫的表

數據庫：db_user  
表1： tb_userinfo 
表2： tb_postinfo

mysql> select * from tb_userinfo;
+----------+--------+
| username | userid |
+----------+--------+
| caixibei | 001    |
| caixibei | 002    |
+----------+--------+
2 rows in set (0.00 sec)

mysql> select * from tb_postinfo;
+----------+--------+--------+
| postname | postid | userid |
+----------+--------+--------+
| t1       | 001    | 001    |
| t2       | 002    | 002    |
| t3       | 003    | 002    |
| t4       | 004    | 003    |
| t1       | 001    | 001    |
| t2       | 002    | 002    |
+----------+--------+--------+
6 rows in set (0.00 sec)

一個用戶對應多個帖子
2、新建一個java項目：mybatis_0927

3、代碼
1)兩個實體類對應兩張表

//User.java
private String username,userid;
private List<Post> posts;

//Post.java
private String postname,postid ;
private User user;

2)配置文件的編寫：mybatis-config.xml && mybatis-usermapper.xml && db.properties

<!--mybatis-config.xml-->
<?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>
	<properties resource="db.properties"/>
	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC"/>
			<dataSource type="POOLED">
				<property name="driver" value="${driver}"/>
				<property name="url" value="${url}"/>
				<property name="username" value="${username}"/>
				<property name="password" value="${password}"/>
			</dataSource>
		</environment>
	</environments>
	<mappers>
		<mapper resource="mybatis-tb_usermapper.xml"/>	
	</mappers>
</configuration>

<!--mybatis-tb_usermapper.xml-->
<?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="operateTb_userinfo">
	<select id="selectUsers" resultType="my.entity.User">
		select * from tb_userinfo;
	</select>
	
	<select id="selectUserById" resultMap="selectUserMap">
		select tb_userinfo.*,tb_postinfo.* from tb_postinfo,tb_userinfo
		where tb_userinfo.userid=tb_postinfo.userid 
		and tb_userinfo.userid=#{userid};
	</select>
	<resultMap type="my.entity.User" id="selectUserMap">
		<result property="username" column="username" />
		<result property="userid" column="userid" />
		<collection property="postlist" ofType="my.entity.Posts" >
			<result property="postname" column="postname"/>
			<result property="postid" column="postid"/>
			<result property="userid" column="userid"/>
		</collection>
	</resultMap>
</mapper>

//參數配置文件
url=jdbc:mysql://127.0.0.1:3306/db_user
username=root
password=caixibei
driver=com.mysql.jdbc.Driver

i.分析

ii.關於resultMap標籤：

 部分元素結構：
 <resultMap type="" id="">
	<result />		注入到字段或javaBean屬性的普通結果
	<collection />	用於一對多關聯
	<id />  		用於表示哪一個是主鍵
	<association> 	用於一對一關聯
</resultMap>  

4)日誌機制

1、我們添加下面兩個jar包完成日誌機制

a. log4j-1.2.17.jar
b. commons-logging-1.2.jar

2、日誌機制的配置文件

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=D:\mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###
### fatal error warn info debug trace
log4j.rootLogger=debug, stdout

4)測試代碼

package my.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import my.entity.User;
public class Test01 {
	public static void main(String[] args) throws IOException {
		InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
		SqlSession sqlSession = sqlSessionFactory.openSession();
		List<User> list = sqlSession.selectList("operateTb_userinfo.selectUserById","002");
		for(User user:list) {
			System.out.println(user);
		}
	}
}

4、測試

第四節課 Mybatis表關聯（一對一）

1、我們在上一節課的項目基礎上mybatis_1002

2、使用Mapper代理

 注意事項：
 Mapper接口開發需要遵循以下規範：
	1、 Mapper.xml文件中的namespace與mapper接口的類路徑相同。
	2、 Mapper接口方法名和Mapper.xml中定義的每個statement的id相同
	3、 Mapper接口方法的輸入參數類型和mapper.xml中定義的每個sql 的parameterType的類型相同
	4、 Mapper接口方法的輸出參數類型和mapper.xml中定義的每個sql的resultType的類型相同

ps:每個用戶只能擁有一個身份證信息,所以用戶和身份信息是一對一的關係，也就是說 用戶(User)-身份證號(IdCard)（一對一）

3、代碼
1)數據庫文件從今天開始，我們就不再使用mysql進行操作了，我們全部統一使用oracle數據庫吧！

--oracle數據庫連接參數 
username=system
password=caixibei
url=jdbc:oracle:thin:@127.0.0.1:1521:user
driver=oracle.jdbc.OracleDriver

編碼展示：

//1、User.java
private String username,userid;
private Card card;


//2、Card.java
private String cardid,code;


//3、UserDao.java
package my.dao;
import my.entity.User;
public interface UserDao {
	//提供一個查詢的方法
	public User selectUserById(String userid);
}


//4、CardDao.java
package my.dao;
import my.entity.Card;
public interface CardDao {
	public Card selectCardById(String userid);
}


//5、TestClass.java
package my.test;
import java.io.IOException;
import java.io.InputStream;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import my.dao.UserDao;
import my.entity.User;
public class TestClass {
	public static void main(String[] args) throws IOException {
		//1、加載數據庫核心配置文件
		InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
		//2、創建工廠
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
		//3、創建會話
		SqlSession sqlSession = sqlSessionFactory.openSession();
		//4、獲取Mapper接口映射
		UserDao userDao = sqlSession.getMapper(UserDao.class);
		//5、執行數據庫的操作
		User user = userDao.selectUserById("006");
		
		//6、打印輸出
		System.out.println(user);
	}
}

配置文件

<!--mybatis-config.xml-->
<?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>
	<!-- 數據庫源文件參數映射 -->
	<properties resource="db.properties" />
	
	<!-- 配置數據庫的源數據 -->
	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="username" value="${username}"/>
				<property name="password" value="${password}"/>
				<property name="url" value="${url}"/>
				<property name="driver" value="${driver}"/>
			</dataSource>
		</environment>
	</environments>
	<!-- 操作某個數據庫文件映射 -->
	<mappers>
		<!-- 表：tb_userinfo -->
		<mapper resource="usermapper.xml"/>
		<mapper resource="cardmapper.xml"/>
	</mappers>
</configuration>

<!--usermapper.xml-->
<?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="my.dao.UserDao">
	<!-- 查詢用戶信息+用戶的博文+身份 -->
	<select id="selectUserById" resultMap="userMap">
		select * from userinfo where userid=#{userid}
	</select>
	<resultMap type="my.entity.User" id="userMap">
		<result property="username" column="username"/>
		<result property="userid" column="userid"/>
		<!-- 一對一 -->
		<association property="card" column="cardid" select="my.dao.CardDao.selectCardById"/>
	</resultMap>
</mapper>
<!--cardmapper.xml-->
<?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="my.dao.CardDao">
	<select id="selectCardById" resultType="my.entity.Card">
		select * from cardinfo where cardid=#{cardid}
	</select>
</mapper>

4、效果

今天，我們繼續打點雞血，把動態SQL的其他操作稍微帶過一下,至於具體的代碼操作請各位自行編寫總結經驗！

1、<if/>   	判斷語句，用於單一條件分支判斷
2、<choose>(<when/> <otherwise>)相當於java中的switch...case...default語句，用於多分支判斷
3、<where>、<trim>、<set>輔助元素，用於字符串的SQL拼裝、特殊字符問題
4、<bind>	從OGNL表達式中創建一個變量，並將其綁定到上下文，常用於模糊查詢的sql中

第五節課 動態SQL語句

1、基本操作，還是新建一個Web項目吧：mybatis_1003

2、我們看下數據庫user裏面的表記錄，方便我們後期的操作

3、代碼
我們看到這裏有三個列，且他的列標題是

username
userid
cardid

所以我們需要新建一個與表userinfo對應的實例類

package my.entity;
public class User {
	//設置屬性
	private String username,userid,cardid;
	//無參構造+帶參構造

	public User() {
		super();
	}
	public User(String username, String userid, String cardid) {
		super();
		this.username = username;
		this.userid = userid;
		this.cardid = cardid;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getUserid() {
		return userid;
	}
	public void setUserid(String userid) {
		this.userid = userid;
	}
	public String getCardid() {
		return cardid;
	}
	public void setCardid(String cardid) {
		this.cardid = cardid;
	}
	@Override
	public String toString() {
		return "User [username=" + username + ", userid=" + userid + ", cardid=" + cardid + "]";
	}
}

然後，對應的我們需要寫好數據庫的配置文件

參數配置：db.properties

url=jdbc:oracle:thin:@127.0.0.1:1521:user
username=system
password=caixibei
driver=oracle.jdbc.OracleDriver

然後，我們需要寫mybatis的全局配置文件：mybatis-config.xml

<?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>

	<!-- 加載參數配置文件db.properties -->
	<properties resource="/config/db.properties"/>
	
	<!-- 配置數據源 -->
	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC"/>
			<dataSource type="POOLED">
				<property name="username" value="${username}"/>
				<property name="password" value="${password}"/>
				<property name="url" value="${url}"/>
				<property name="driver" value="${driver}"/>
			</dataSource>
		</environment>
	</environments>
	<mappers>
		<mapper resource="/config/usermapper.xml" />
	</mappers>
	
</configuration>

然後，我們需要表的sql映射文件：usermapper.xml

<?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="my.dao.UserDao">
	<!-- 1、查詢 -->
	<select id="selectUserByIdOrName" resultType="my.entity.User">
		select * from userinfo where 1=1
		<choose>
			<!-- 都非空 -->
			<when test="userid!=null and username!=''">
				and userid like #{userid}||'%' and username like #{username}||'%'
			</when>
			<!-- username爲空，就只需要查userid -->
			<when test="username==null or username==''">
				and userid like #{userid}||'%' and username like #{username}||'%'
			</when>
			<!-- userid爲空，就只需要查username -->
			<when test="userid==null or userid==''">
				and username like #{username}||'%' and userid like '%'||#{userid}||'%'
			</when>
		</choose>
	</select>
</mapper>

然後，我們需要dao層接口完成代理操作：UserDao

package my.dao;
import org.apache.ibatis.annotations.Param;

import my.entity.User;
public interface UserDao {
	//根據userid+username修改信息
	public List<User> selectUserByIdOrName(@Param("username")String username,@Param("userid")String userid);
}

最後，我們需要一個servlet服務類去調用操作接口的方法實現數據庫的操作

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		request.setCharacterEncoding("UTF-8");
		response.setContentType("text/html;charset=utf-8");
		//接受頁面傳來的值
		String username = request.getParameter("username");
		String userid = request.getParameter("userid");
		
		//加載核心配置文件
		InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
		//通過核心配置文件創建會話工廠
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
		//通過工廠打開會話
		SqlSession sqlSession = sqlSessionFactory.openSession();
		UserDao userDao = sqlSession.getMapper(UserDao.class);
		//調用查詢方法
		List<User> list = userDao.selectUserByIdOrName(username, userid);
		
		//打印輸出
		System.out.println(list==null);
		if(list==null) {
			System.out.println("查無此人");
		}
		for(User user:list) {
			System.out.println(user);
		}
	}

4、運行效果

1）輸入全爲空的時候，默認查詢所有：

2) 當只輸入userid的時候，查詢userid匹配的

5、關於更多的動態SQL操作，請自行前往學習…

第五節課 逆向工程

mybatis逆向工程

第六節課 第一個Spring應用程序

1、導包、基本的jar包就這六個
	commons-logging-1.2.jar
	spring-aop-4.3.18.RELEASE.jar
	spring-beans-4.3.18.RELEASE.jar
	spring-context-4.3.18.RELEASE.jar
	spring-core-4.3.18.RELEASE.jar
	spring-expression-4.3.18.RELEASE.jar
2、我們都知道spring的兩大特性：IOC控制反轉、DI依賴注入，所以我們需要SpringIOC容器上下文配置文件applicationContext.xml

applicationContext.xml上下文配置文件

<?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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
	
	<!-- 通過setter\getter進行依賴注入，這種方式的依賴注入基於實例類的setter和getter方法 -->
	<bean id="t_01" class="my.entity.Student">
		<property name="t_name" value="蔡熙貝" />
		<property name="t_id" value="2017120107"/>
		<property name="t_gender" value="男" />
	</bean>
	
	<!-- 通過構造器進行依賴注入，這種構造方法依賴實例類的構造方法 -->
	<bean id="t_02" class="my.entity.Student">
		<constructor-arg value="王安石" />
		<constructor-arg value="2014010322"/>
		<constructor-arg value="男" />
	</bean>
	
	<!-- 通過p命名空間進行依賴注入 -->
	<bean id="t_03" class="my.entity.Student" p:t_name="李小白" p:t_id="2017128282" p:t_gender="男" />
	

</beans>

實例類Student.java

	private String t_name;
	private String t_id;
	private String t_gender;

Test.java

package my.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import my.entity.Student;
public class Test {
	public static void main(String[] args) {
		//測試
		test();
	}
	public static void test() {
		//加載spring ioc全局配置文件
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		//獲取bean
		Student student1 = (Student)context.getBean("t_01");
		Student student2 = (Student)context.getBean("t_02");
		Student student3 = (Student)context.getBean("t_03");
		//輸出bean
		System.out.println(student1);
		System.out.println(student2);
		System.out.println(student3);
	}
}

分析

運行效果：

第七節課 對象構造的三種方法

第一種：通過默認的構造方法進行獲取
該方法不再另行做過多講解…

第二種：通過靜態工廠獲取對象

新建靜態工廠

package server;
import entity.Student;
public class StudentDao {
	public static Student getStudent() {
		return new Student();
	}
}

學生實例對象

private String name;
private String gender;
private int age;

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	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">

	<!-- 採用靜態工廠的方法獲取Bean對象 -->
	<bean id="student" class="server.StudentDao" factory-method="getStudent"></bean>

</beans>

分析

測試類

package test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import entity.Student;
public class Test {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
		Student student = (Student)context.getBean("student");
		student.setName("才西北");
		System.out.println(student);
	}
}

第三種：通過實例工廠構造對象

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	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">

	<!-- 採用實例工廠的方法獲取Bean對象 -->
	<!-- 工廠 -->
	<bean id="studentFactory" class="server.StudentDao" />
	<!-- 通過工廠調用得到實例Student -->
	<bean id="student" factory-bean="studentFactory" factory-method="getStudent" />

</beans>

分析

第八節課 spring之面向切面編程AOP

1、AOP的相關名詞

2、AOP的通知類型

3、通過XML文件進行AOP通知

1）前置通知
配置文件

前置通知方法

業務類

測試方法

2)後置通知

配置文件

業務類

3)環繞通知請自行測試

聲明：環繞通知的接口invoke()方法會對調用的業務類方法進行攔截！

4、通過註解進行AOP通知

1)前置通知

配置文件

前置通知

業務類

測試

2)後置通知

自行編寫

第*節課 第一個Spring MVC應用程序

1、爲甚麼要使用Spring MVC框架？

2、現在我們開始我們的第一個Spring mvc應用程序，構建一個動態項目如下：

3、然後我們需要配置web.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
  <display-name>springmvc_1024</display-name>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  
  
  	<!-- 1、配置Spring IOC容器的監聽器 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value></param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
  	<!-- 2、配置前端過濾器 -->
	<servlet>
		<servlet-name>dispatcher</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>dispatcher</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
  
  	<!-- 3、配置頁面的編碼過濾器 -->
 	<filter>
 		<filter-name>encoding</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>
 		<init-param>
 			<param-name>forceEncoding</param-name>
 			<param-value>true</param-value>
 		</init-param>
 	</filter>
 	<filter-mapping>
 		<filter-name>encoding</filter-name>
 		<url-pattern>/*</url-pattern>
 	</filter-mapping>
  
  
</web-app>

PS:編碼過濾器是根據甚麼寫的？

打開jar包的資源文件，你會發現他的構造方法中的兩個屬性：String encoding ,boolean forceEncoding

因爲我還沒有新建spring ioc容器的文件，故而上述web.xml文件中沒有指定容器的位置

4、編寫dispatcher-servlet.xml控制器文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	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">

	<!-- 視圖解析器 -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<!-- 配置前綴 -->
		<property name="prefix" value="/jsp/" />
		<!-- 配置後綴 -->
		<property name="suffix" value=".jsp"/>
	</bean>

	<bean id="helloWorldController" class="com.xixijiazi.controller.HelloWorldController"/>

</beans>

5、控制器

package com.xixijiazi.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class HelloWorldController{
	@RequestMapping(value = "/jsp/index.do")
	public ModelAndView index() {
		return new ModelAndView("index","message","HelloWorld!");
	}

}

6、補充

7、項目完整路徑

8、總結：spring mvc 好騷啊！！！

第*節課 Spring MVC表單處理

1、新建web項目如下：

2、需求：模擬用戶登錄，登陸成功後跳轉到獲取用戶登錄的信息頁面

3、我們需要新建頁面：

//首頁index.jsp
<body>
	<h3>歡迎來到熙熙佳榟電子書城，點擊登錄<a href="/springmvc_1025/login.action">登錄   & 註冊</a></h3>
</body>

首頁預覽：

//用戶登錄頁面：login.jsp
<body>
	請在下面填寫表格完成登錄信息的註冊：
	<%-- <form action="/loginBack.action" method="post">
		姓名：<input type="text" name="username"/>
		年齡:<input type="number" name="age"/>
		登錄名：<input type="text" name="loginname"/>
		密碼:<input type="password" name="password"/> 
	</form> --%>
	
	<form:form action="/springmvc_1025/loginBack.action" commandName="user">
		姓名：<form:input path="username"/>
		年齡：<form:input path="age"/>
		登錄名：<form:input path="loginname"/>
		密碼：<form:password path="password"/> 
		<input type="submit" value="提交">
	</form:form>
</body>

登錄界面預覽：

//登錄成功頁面：success.jsp
<body>
${user }
</body>

界面預覽：

4、頁面寫好了，我們需要配置好spring ioc的配置文件以及mvc的配置文件

//web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
  <display-name>springmvc_1025</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  
 	<!-- 配置spring ioc容器的監聽器 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>/WEB-INF/applicationContext.xml</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	
	<!-- 配置前端過濾器 -->
	<servlet>
		<servlet-name>dispatcher</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>dispatcher</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
	
	<!-- 配置編碼過濾器 -->
	<filter>
		<filter-name>encoding</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>
		<init-param>
			<param-name>forceEncoding</param-name>
			<param-value>true</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>encoding</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
</web-app>

//dispatcher-servlet.xml
<?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-4.3.xsd">

	
	<context:component-scan base-package="xixijiazi.controller"/>
	
	<!-- 視圖解析器 -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/jsp/" />
		<property name="suffix" value=".jsp" />
	</bean>
</beans>

//applicationContext.xml
<?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-4.3.xsd">
	
	<context:component-scan base-package="xixijiazi.entity"/>
</beans>

5、然後我們就需要寫好控制器

package xixijiazi.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import xixijiazi.entity.User;
@Controller
public class LoginController {
	
	@Autowired
	@Qualifier("user")
	private User user;
	
	//創建入口的Model
	@ModelAttribute("user")
	public User getUser() {
		return user;
	}
	
	//跳轉到登陸界面進行登錄
	@RequestMapping("/login.action")
	public String login() {
		return "login";
	}
	
	//跳轉到登錄成功頁面或者重新登錄
	@RequestMapping("/loginBack.action")
	public String loginBack(User user,Model model) {
		model.addAttribute("user",user);
		return "success";
	}
}

6、運行效果上面已經展示過了

Spring MVC之文件上傳

前言: 經過前面的學習，我們學習了很多關於Spring MVC表單的事項，現在我們模擬做一個文件上傳的網站。
1、創建一個動態Web項目：Xftp
2、

Spring 整合Mybatis

1、創建項目：ssm
2、我們都知道在mybatis中，也能操作數據庫（增刪改查），spring同樣也可以實現
但是如果需要整合在一起又是如何去整合的呢？
3、項目結構：

4、整合的步驟
1）導入相關的jar包
2）配置數據庫的參數文件db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/cxb?useUnicode=true&characterEncoding=utf-8
jdbc.username=root 
jdbc.password=caixibei

3)配置spring ioc上下文配置文件

<!-- 1、加載參數文件db.properties -->
<context:property-placeholder location="classpath:db.properties"/>

<!-- 2、配置數據源：使用c3p0數據源  -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
	<property name="jdbcUrl" value="${jdbc.url}"/>
	<property name="driverClass" value="${jdbc.driver}"/>
	<property name="user" value="${jdbc.username}"/>
	<property name="password" value="${jdbc.password}"/>
</bean>

<!-- 
		在Mybatis中我們需要的是一個mybatis-config.xml的文件配置好數據源
	，獲取SqlSession對象操作數據庫
-->

<!-- 3、加載SqlSessionFactoryBean對象 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	<!-- 配置mybatis核心配置文件 -->
	<property name="configLocation" value="classpath:mybatis-config.xml"/>
	
	<!-- 加載數據源 -->
	<property name="dataSource" ref="dataSource"/>
	
	<!-- 加載mapper映射文件 -->
	<property name="mapperLocations" value="classpath:student-mapper.xml"/>
</bean>

<!-- 4、獲取SqlSession對象：SqlSessionTemplate是一個安全線程對象，每一次運行都會獲取一個新的SqlSession對象 -->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> 
	<constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

4)配置springmvc的相關配置
1.在web.xml文件中配置前端頁面控制器

  	<!-- 配置spring ioc文件的監聽器 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:applicationContext.xml</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
  	
  	<!-- 配置前端頁面控制器 -->
	<servlet>
		<servlet-name>dispatcher</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>dispatcher</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
	
	<!-- 配置編碼過濾器 -->
	<filter>
		<filter-name>encoding</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>
		<init-param>
			<param-name>forceEncoding</param-name>
			<param-value>true</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>encoding</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
</web-app>

2.在dispatcher-servlet.xml文件中配置視圖解析器

	<!-- 配置控制器 -->
	<context:component-scan base-package="my.controller"/>
	<!-- 配置視圖解析器 -->
	<bean id="resourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/jsp/" />
		<property name="suffix" value=".jsp" />
	</bean>

3、在student-mapper.xml文件中編寫操作數據庫的SQL語句

<?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="my.service">
	<select id="selectStudentByNo" resultType="my.entity.Student">
	 	update student
	 	set sname='caixibei'
	 	where sno=#{sno}
	</select>
</mapper>

4、配置spring ioc的上下文配置文件

<!-- 1、加載參數文件db.properties -->
	<context:property-placeholder location="classpath:db.properties"/>
	
	<!-- 2、配置數據源：使用c3p0數據源  -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="jdbcUrl" value="${jdbc.url}"/>
		<property name="driverClass" value="${jdbc.driver}"/>
		<property name="user" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>
	
	<!-- 
			在Mybatis中我們需要的是一個mybatis-config.xml的文件配置好數據源
		，獲取SqlSession對象操作數據庫
	-->
	
	<!-- 3、加載SqlSessionFactoryBean對象 -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<!-- 配置mybatis核心配置文件 -->
		<property name="configLocation" value="classpath:mybatis-config.xml"/>
		<!-- 加載數據源 -->
		<property name="dataSource" ref="dataSource"/>
		<!-- 加載映射文件 -->
		<property name="mapperLocations" value="classpath:student-mapper.xml"/>
	</bean>
	
	<!-- 4、獲取SqlSession對象：SqlSessionTemplate是一個安全線程對象，每一次運行都會獲取一個新的SqlSession對象 -->
	<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> 
		<constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory" />
	</bean>
	
	<!-- 5、配置SqlSession對象:給StudentService配置屬性，必須要有setter()方法 -->
	<bean id="studentService" class="my.service.StudentService">
		<property name="sqlSession" ref="sqlSession"/>
	</bean>

5、配置mybatis核心配置文件

<?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> 
	<!--1.全局的setting配置，根據需要添加 -->
	<settings> 
		<!--開啓二級緩存 -->
		<setting name="cacheEnabled" value="true" />
	</settings> 
</configuration>

6、前端頁面

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Welcome to my WebSite</title>
</head>
<body>
	<h3>歡迎來到我的網站，<a href="/ssm/updatePage.action">點擊修改信息</a></h3>
</body>
</html>

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>更新數據庫</title>
</head>
<body>
	<form action="/ssm/updateStudent.action" method="post">
		請輸入您要修改的學號：<input type="text" name="sno" />
		<input type="submit" value="確認" />
	</form>
	${message }
</body>
</html>

7、控制器

package my.controller;
import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;

import my.service.StudentService;
@Controller
public class StudentController {
	@Autowired
	@Qualifier("studentService")
	private StudentService studentService;
	@RequestMapping(value="/updatePage.action")
	public String updatePage() {
		return "updateStudent";
	}
	
	@RequestMapping(value = "/updateStudent.action")
	public String updateStudent(HttpServletRequest request,ModelMap modelMap ) {
		String sno = request.getParameter("sno");
		studentService.updateStudent(sno);
		modelMap.addAttribute("message", "修改成功..");
		return "updateStudent";
	}
	
}

8、Dao層接口

package my.dao;
import my.entity.Student;
public interface StudentDao {
	//查詢學生
	public Student selectStudentBySno(String sno) ;
	//刪除學生
	public void deleteStudentBySno(String sno);
	//更新學生
	public void updateStudent(String sno);
	//增加學生
	public void insertStudent(Student student);
}

9、業務層

package my.service;
import org.apache.ibatis.session.SqlSession;
import my.dao.StudentDao;
import my.entity.Student;
public class StudentService implements StudentDao{
	private SqlSession sqlSession;
	public void setSqlSession(SqlSession sqlSession) {
		this.sqlSession = sqlSession;
	}
	@Override
	public Student selectStudentBySno(String sno) {
		return null;
	}

	@Override
	public void deleteStudentBySno(String sno) {
		
	}

	//根據學號修改學生的姓名
	@Override
	public void updateStudent(String sno) {
		int i = sqlSession.update("my.service.selectStudentByNo", sno);
	}

	@Override
	public void insertStudent(Student student) {
		
	}

}

4)測試


5）bingo…完結