首先给大家推荐几个网页：
http://blog.csdn.net/isea533/article/category/2092001 没事看看 - MyBatis工具：www.mybatis.tk
http://www.mybatis.org/mybatis-3/zh/getting-started.html 入门
http://edu.51cto.com/course/course_id-1354.html mybatis视频教程
今天主要学习的关联关系是一对一关系与一对多关系。
一、一对一关系
还是通过例子来解释说明。（一个妻子对应一个丈夫）。
1)数据库信息
1 create table t_wife( 2 id int primary key auto_increment, 3 wife_name varchar(20), 4 fk_husband_id int 5 ); 6 7 create table t_husband( 8 id int primary key auto_increment, 9 husband_name varchar(20) 10 ); 11 12 insert into t_husband values (null,'hello'); 13 insert into t_wife values(null,'kitty',1)
2）对应的JavaBean代码
虽然在数据库里只有一方配置的外键，但是这个一对一是双向的关系。
HusbandBean.java
1 package com.cy.mybatis.beans;
2
3 import java.io.Serializable;
4 /**
5 * one to one
6 * @author acer
7 *
8 */
9 public class HusbandBean implements Serializable{
10
11
12 private static final long serialVersionUID = 1L;
13
14 private Integer id;
15 private String name;
16 private WifeBean wife;
17 public HusbandBean() {
18 super();
19 }
20 public HusbandBean(Integer id, String name, WifeBean wife) {
21 super();
22 this.id = id;
23 this.name = name;
24 this.wife = wife;
25 }
26 public Integer getId() {
27 return id;
28 }
29 public void setId(Integer id) {
30 this.id = id;
31 }
32 public String getName() {
33 return name;
34 }
35 public void setName(String name) {
36 this.name = name;
37 }
38 public WifeBean getWife() {
39 return wife;
40 }
41 public void setWife(WifeBean wife) {
42 this.wife = wife;
43 }
44 @Override
45 public String toString() {
46 return "Husband [id=" + id + ", name=" + name + ", wife=" + wife + "]";
47 }
48
49
50
51 }
WifeBean.java
1 package com.cy.mybatis.beans;
2
3 import java.io.Serializable;
4 /**
5 * one to one
6 * @author acer
7 *
8 */
9 public class WifeBean implements Serializable{
10
11 private static final long serialVersionUID = 1L;
12 private Integer id;
13 private String name;
14 private HusbandBean husband;
15 public WifeBean() {
16 super();
17 }
18 public WifeBean(Integer id, String name, HusbandBean husband) {
19 super();
20 this.id = id;
21 this.name = name;
22 this.husband = husband;
23 }
24 public Integer getId() {
25 return id;
26 }
27 public void setId(Integer id) {
28 this.id = id;
29 }
30 public String getName() {
31 return name;
32 }
33 public void setName(String name) {
34 this.name = name;
35 }
36 public HusbandBean getHusband() {
37 return husband;
38 }
39 public void setHusband(HusbandBean husband) {
40 this.husband = husband;
41 }
42 @Override
43 public String toString() {
44 return "Wife [id=" + id + ", name=" + name + ", husband=" + husband
45 + "]";
46 }
47
48
49 }
View Code
3）接下来建立两个接口，HusbandMapper,WifeMapper.
HusbandMapper
1 package com.cy.mybatis.mapper;
2
3 import com.cy.mybatis.beans.HusbandBean;
4
5 public interface HusbandMapper {
6 /**
7 * 根据id查询丈夫信息
8 * @param id
9 * @return
10 * @throws Exception
11 */
12 public HusbandBean selectHusbandById (int id) throws Exception;
13
14 /**
15 * 根据id查询丈夫与妻子信息
16 * @param id
17 * @return
18 * @throws Exception
19 */
20 public HusbandBean selectHusbandAndWife(int id) throws Exception;
21
22 }
View Code
4）定义HusbandMapper.xml文件
1 <?xml version="1.0" encoding="UTF-8"?>
2 <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3 <mapper namespace="com.cy.mybatis.mapper.HusbandMapper">
4
5 <resultMap type="HusbandBean" id="husbandAndWife">
6 <id property="id" column="id" javaType="java.lang.Integer"/>
7 <result property="name" column="name" javaType="java.lang.String"/>
8
9 <!-- association – 一个复杂的类型关联；许多结果将包成这种类型
10 嵌入结果映射 – 结果映射自身的关联，或者参考一个
11 column="id" 这里的id指的是在t_wife表来的主键id
12 这个查询妻子，所以在妻子mapper里有个方法 -->
13 <association property="wife" column="id" javaType="WifeBean" select="com.cy.mybatis.mapper.WifeMapper.selectWifeByHusbandId" ></association>
14 </resultMap>
15
16 <!-- resultType 返回类型 从这条语句中返回的期望类型的类的完全限定名或别名
17 。-->
18 <select id="selectHusbandById" resultType="HusbandBean">
19 select * from t_husband where id=#{id}
20 </select>
21
22 <!-- resultMap 命名引用外部的 resultMap。返回的是一个集合。-->
23 <select id="selectHusbandAndWife" resultMap="husbandAndWife">
24 select * from t_husband where id=#{id}
25 </select>
26
27
28
29
30 </mapper>
在WifeMapper.xml里有个方法
1 <?xml version="1.0" encoding="UTF-8"?>
2 <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3
4 <mapper namespace="com.cy.mybatis.mapper.WifeMapper">
5 <select id="selectWifeByHusbandId" resultType="WifeBean">
6 select * from t_wife where fk_husband_id = #{id}
7
8 </select>
9 </mapper>
5）写个实现
1 package com.cy.mybatis.service;
2
3 import org.apache.ibatis.session.SqlSession;
4
5 import com.cy.mybatis.beans.HusbandBean;
6 import com.cy.mybatis.mapper.HusbandMapper;
7 import com.cy.mybatis.tools.DBTools;
8
9
10
11
12 public class OneToOneService {
13
14 public static void main(String[] args) {
15 selectHusbandAndWife();
16
17 }
18
19
20 private static void selectHusbandAndWife() {
21 SqlSession session = DBTools.getSession();
22 HusbandMapper hm = session.getMapper(HusbandMapper.class);
23 try {
24 HusbandBean husband = hm.selectHusbandAndWife(1);
25 System.out.println(husband);
26 session.commit();
27 } catch (Exception e) {
28 e.printStackTrace();
29 }
30 }
31
32 }
注意：那个工具类还是前一章那样写的，就相当与在昨天的基础上建立的。
注意：
mybatis实际是对XML进行操作，我们所有的方法都直接定义在XML中，写个接口只是为了更好的符合我们3层的思想，如果不写接口，直接通过session也可以直接操作xml中的方法 ，
XML中只要有方法，就可以使用，而调用的方式就是：namespace+方法名；
例外使用resultType时，一定要保证，你属性名与字段名相同；
如果不相同，就使用resultMap 。
二、一对多关系
还是通过例子来解释说明。（一把锁对应多把钥匙）。
2.1）数据库信息 这里没有添加数据了，我们用批量添加数据
1 create table t_key( 2 id int primary key auto_increment, 3 key_name varchar(20), 4 fk_lock_id int 5 ); 6 7 8 create table t_lock( 9 id int primary key auto_increment, 10 lock_name varchar(20) 11 );
2.2) 实体类
KeyBean.java
1 package com.cy.mybatis.beans;
2
3 import java.io.Serializable;
4 /**
5 * manyTOone
6 *
7 *
8 */
9 public class KeyBean implements Serializable {
10
11
12 private static final long serialVersionUID = 3712545874604618746L;
13
14 private Integer id;
15 private String key;
16
17 private LockBean lock;
18
19 public KeyBean() {
20 super();
21 }
22
23 public KeyBean(Integer id, String key, LockBean lock) {
24 super();
25 this.id = id;
26 this.key = key;
27 this.lock = lock;
28 }
29
30 public Integer getId() {
31 return id;
32 }
33
34 public void setId(Integer id) {
35 this.id = id;
36 }
37
38 public String getKey() {
39 return key;
40 }
41
42 public void setKey(String key) {
43 this.key = key;
44 }
45
46 public LockBean getLock() {
47 return lock;
48 }
49
50 public void setLock(LockBean lock) {
51 this.lock = lock;
52 }
53
54 @Override
55 public String toString() {
56 return "KeyBean [id=" + id + ", key=" + key + ", lock=" + lock + "]";
57 }
58
59 }
View Code
LockBean.java
1 package com.cy.mybatis.beans;
2
3 import java.io.Serializable;
4 import java.util.List;
5 /**
6 * oneTOmany
7 *
8 *
9 */
10 public class LockBean implements Serializable{
11
12 private static final long serialVersionUID = 7092410462131162665L;
13
14 private Integer id;
15 private String lock;
16
17 private List<KeyBean> keys;
18
19 public LockBean() {
20 super();
21 }
22
23 public LockBean(Integer id, String lock, List<KeyBean> keys) {
24 super();
25 this.id = id;
26 this.lock = lock;
27 this.keys = keys;
28 }
29
30 public Integer getId() {
31 return id;
32 }
33
34 public void setId(Integer id) {
35 this.id = id;
36 }
37
38 public String getLock() {
39 return lock;
40 }
41
42 public void setLock(String lock) {
43 this.lock = lock;
44 }
45
46 public List<KeyBean> getKeys() {
47 return keys;
48 }
49
50 public void setKeys(List<KeyBean> keys) {
51 this.keys = keys;
52 }
53
54 @Override
55 public String toString() {
56 return "LockBean [id=" + id + ", keys=" + keys + ", lock=" + lock + "]";
57 }
58
59 }
View Code
2.3) 建立接口
KeyMapper.java
1 package com.cy.mybatis.mapper;
2
3 import java.util.List;
4
5 import org.apache.ibatis.annotations.Param;
6
7 import com.cy.mybatis.beans.KeyBean;
8
9 public interface KeyMapper {
10 /**
11 * 批量添加钥匙
12 * @return
13 * 提倡 这样使用 @Param("keys")
14 */
15 public int batchSaveKeys(@Param("keys")List<KeyBean> keys);
16 }
LockMapper.java
1 package com.cy.mybatis.mapper;
2
3 import org.apache.ibatis.annotations.Param;
4
5 import com.cy.mybatis.beans.LockBean;
6
7 public interface LockMapper {
8 /**
9 * 添加锁
10 * @param lock
11 * @return
12 */
13 public int saveLock(@Param("lock")LockBean lock);
14
15 /**
16 * 根据ID查询锁的资料
17 * @param id
18 * @return
19 */
20 public LockBean findLockById(int id);
21
22 /**
23 * 根据ID查询锁与钥匙的资料
24 * one2many
25 * @param id
26 * @return
27 */
28 public LockBean findLockAndKeys(int id);
29
30 }
2.4) 建立xml文件
KeyMapper.xml
1 <?xml version="1.0" encoding="UTF-8"?>
2 <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3 <mapper namespace="com.cy.mybatis.mapper.KeyMapper">
4
5 <resultMap id="keyMap" type="KeyBean">
6 <id property="id" column="id" javaType="java.lang.Integer"/>
7 <result property="key" column="key_name" javaType="java.lang.String"/>
8 </resultMap>
9
10
11 <!--collection 为用于遍历的元素（必选），支持数组、List、Set -->
12 <!-- item 表示集合中每一个元素进行迭代时的别名. -->
13 <!--separator表示在每次进行迭代之间以什么符号作为分隔 符. -->
14 <insert id="batchSaveKeys">
15 insert into t_key values
16 <foreach collection="keys" item="key" separator=",">
17 (null,#{key.key},#{key.lock.id})
18 </foreach>
19 </insert>
20
21 <select id="findKeysByLockId" resultMap="keyMap">
22 select * from t_key where fk_lock_id = #{id}
23 </select>
24
25 </mapper>
LockMapper.xml
1 <?xml version="1.0" encoding="UTF-8"?>
2 <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3 <mapper namespace="com.cy.mybatis.mapper.LockMapper">
4 <!--自定义返回类型 -->
5 <resultMap id="lockMap" type="LockBean">
6 <id property="id" column="id" javaType="java.lang.Integer"/>
7 <result property="lock" column="lock_name" javaType="java.lang.String"/>
8 </resultMap>
9
10 <!--自定义返回类型 -->
11 <resultMap id="lockAndKeysMap" type="LockBean">
12 <id property="id" column="id" javaType="java.lang.Integer"/>
13 <result property="lock" column="lock_name" javaType="java.lang.String"/>
14
15 <collection property="keys" column="id" select="com.cy.mybatis.mapper.KeyMapper.findKeysByLockId"></collection>
16 </resultMap>
17
18 <insert id="saveLock">
19 insert into t_lock values (null,#{lock.lock})
20 </insert>
21
22 <select id="findLockById" resultMap="lockMap">
23 select * from t_lock where id= #{id}
24 </select>
25
26 <select id="findLockAndKeys" resultMap="lockAndKeysMap">
27 select * from t_lock where id= #{id}
28 </select>
29
30 </mapper>
2.5 ） 实现
1 package com.cy.mybatis.service;
2
3 import java.util.ArrayList;
4 import java.util.List;
5
6 import org.apache.ibatis.session.SqlSession;
7
8 import com.cy.mybatis.beans.KeyBean;
9 import com.cy.mybatis.beans.LockBean;
10 import com.cy.mybatis.mapper.KeyMapper;
11 import com.cy.mybatis.mapper.LockMapper;
12 import com.cy.mybatis.tools.DBTools;
13
14 public class OneToManyService {
15 public static void main(String[] args) {
16 // saveLock();
17 // batchSaveKeys();
18 findLockAndKeys();
19 }
20
21 private static void findLockAndKeys() {
22
23 SqlSession session = DBTools.getSession();
24 LockMapper lm = session.getMapper(LockMapper.class);
25 LockBean lock = lm.findLockAndKeys(1);
26 System.out.println(lock);
27 }
28
29 private static void batchSaveKeys() {
30
31 SqlSession session = DBTools.getSession();
32 LockMapper lm = session.getMapper(LockMapper.class);
33 KeyMapper km = session.getMapper(KeyMapper.class);
34
35 LockBean lock = lm.findLockById(1);
36 List<KeyBean> keys = new ArrayList<KeyBean>();
37 for(int i = 0; i < 5; i++){
38 KeyBean key = new KeyBean(null, "钥匙"+i, lock);
39 keys.add(key);
40 }
41 km.batchSaveKeys(keys);
42 session.commit();
43 }
44
45 private static void saveLock() {
46 SqlSession session = DBTools.getSession();
47 LockMapper lm = session.getMapper(LockMapper.class);
48 LockBean lock = new LockBean(null, "锁1", null);
49 lm.saveLock(lock);
50 session.commit();
51 }
52 }
结果显示：
三 、批量操作与分页
这里就使用前一章的User.就写出主要的代码。
首先定义分页对象。
1 package com.cy.mybatis.beans;
2
3 import java.util.List;
4
5
6
7 /**
8 * 定义一个分页对象
9 *
10 * @author
11 *
12 */
13 public class Pager {
14
15 private int pageNo;// 当前页码
16 private int pageTotal;// 总页码
17 private int rowsTotal;// 总条数
18 private int pageSize;// 每页显示条数
19 private List<Object> list;// 返回的数据集合
20
21 public int getPageNo() {
22 return pageNo;
23 }
24
25 public void setPageNo(int pageNo) {
26 this.pageNo = pageNo;
27 }
28
29 public int getPageTotal() {
30 return pageTotal;
31 }
32
33 public void setPageTotal(int pageTotal) {
34 this.pageTotal = pageTotal;
35 }
36
37 public int getRowsTotal() {
38 return rowsTotal;
39 }
40
41 public void setRowsTotal(int rowsTotal) {
42 this.rowsTotal = rowsTotal;
43 pageTotal = rowsTotal % pageSize == 0 ? rowsTotal / pageSize : rowsTotal / pageSize + 1;
44 }
45
46 public int getPageSize() {
47 return pageSize;
48 }
49
50 public void setPageSize(int pageSize) {
51 this.pageSize = pageSize;
52 }
53
54 public List<?> getList() {
55 return list;
56 }
57
58 public void setList(List<Object> list) {
59 this.list = list;
60 }
61
62
63 @Override
64 public String toString() {
65 return "Pager [pageNo=" + pageNo + ", pageTotal=" + pageTotal
66 + ", rowsTotal=" + rowsTotal + ", pageSize=" + pageSize
67 + ", list=" + list + "]";
68 }
69
70 }
UserMapper.java接口。
1 package com.cy.mybatis.mapper;
2
3 import java.util.List;
4 import java.util.Map;
5
6 import org.apache.ibatis.annotations.Param;
7
8 import com.cy.mybatis.beans.UserBean;
9
10 public interface UserMapper {
11 /**
12 * 新增用戶
13 * @param user
14 * @return
15 * @throws Exception
16 */
17 public int insertUser(@Param("user")UserBean user) throws Exception;
18 /**
19 * 修改用戶
20 * @param user
21 * @param id
22 * @return
23 * @throws Exception
24 */
25 public int updateUser (@Param("u")UserBean user,@Param("id")int id) throws Exception;
26 /**
27 * 刪除用戶
28 * @param id
29 * @return
30 * @throws Exception
31 */
32 public int deleteUser(int id) throws Exception;
33 /**
34 * 根据id查询用户信息
35 * @param id
36 * @return
37 * @throws Exception
38 */
39 public UserBean selectUserById(int id) throws Exception;
40 /**
41 * 查询所有的用户信息
42 * @return
43 * @throws Exception
44 */
45 public List<UserBean> selectAllUser() throws Exception;
46
47
48 /**
49 * 批量增加
50 * @param user
51 * @return
52 * @throws Exception
53 */
54 public int batchInsertUser(@Param("users")List<UserBean> user) throws Exception;
55
56 /**
57 * 批量删除
58 * @param list
59 * @return
60 * @throws Exception
61 */
62 public int batchDeleteUser(@Param("list")List<Integer> list) throws Exception;
63
64
65 /**
66 * 分页查询数据
67 * @param parma
68 * @return
69 * @throws Exception
70 */
71 public List<UserBean> pagerUser(Map<String, Object> parmas) throws Exception;
72
73 /**
74 *
75 * 分页统计数据
76 * @param parma
77 * @return
78 * @throws Exception
79 */
80 public int countUser(Map<String, Object> parmas) throws Exception;
81
82
83
84 }
xml文件
1 <?xml version="1.0" encoding="UTF-8"?>
2 <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3 <mapper namespace="com.cy.mybatis.mapper.UserMapper">
4 <!-- 自定义返回结果集 -->
5 <resultMap id="userMap" type="UserBean">
6 <id property="id" column="id" javaType="java.lang.Integer"></id>
7 <result property="username" column="username" javaType="java.lang.String"></result>
8 <result property="password" column="password" javaType="java.lang.String"></result>
9 <result property="account" column="account" javaType="java.lang.Double"></result>
10 </resultMap>
11 <!-- 在各种标签中的id属性必须和接口中的方法名相同 ， id属性值必须是唯一的，不能够重复使用。parameterType属性指明查询时使用的参数类型，resultType属性指明查询返回的结果集类型-->
12 <!-- useGeneratedKeys：（ 仅 对 insert 有 用 ） 这 会 告 诉 MyBatis 使 用 JDBC 的getGeneratedKeys
13 方法来取出由数据（比如：像 MySQL 和 SQLServer 这样的数据库管理系统的自动递增字段）内部生成的主键。默认值： false。 -->
14 <!--keyProperty： （仅对 insert有用）标记一个属性， MyBatis 会通过 getGeneratedKeys或者通过 insert 语句的 selectKey 子元素设置它的值。默认：不设置。 -->
15 <!--#{}中的内容，为占位符，当参数为某个JavaBean时，表示放置该Bean对象的属性值 -->
16
17
18 <insert id="insertUser" useGeneratedKeys="true" keyProperty="user.id">
19 insert into t_user (username,password,account) values (#{user.username},#{user.password},#{user.account})
20 </insert>
21
22 <update id="updateUser">
23 update t_user set username=#{u.username},password=#{u.password},account=#{u.account} where id=#{id}
24 </update>
25
26 <delete id="deleteUser" parameterType="int">
27 delete from t_user where id=#{id}
28 </delete>
29
30 <select id="selectUserById" parameterType="int" resultMap="userMap">
31 select * from t_user where id=#{id}
32 </select>
33
34 <select id="selectAllUser" resultMap="userMap">
35 select * from t_user
36 </select>
37
38
39
40
41 <!-- 批量操作和foreach标签 -->
42
43 <insert id="batchInsertUser" parameterType="java.util.List">
44 insert into t_user values
45 <foreach collection="users" item="users" separator=",">
46 (null,#{users.username},#{users.password},#{users.account})
47 </foreach>
48 </insert>
49
50
51 <delete id="batchDeleteUser">
52 delete from t_user where id in (
53 <foreach collection="list" item="list" separator=",">
54 #{id}
55 </foreach>
56 )
57 </delete>
58
59 <!--collection 为用于遍历的元素（必选），支持数组、List、Set -->
60 <!-- item 表示集合中每一个元素进行迭代时的别名. -->
61 <!--separator表示在每次进行迭代之间以什么符号作为分隔 符. -->
62
63
64 <select id="pagerUser" parameterType="java.util.Map" resultMap="userMap">
65 select * from t_user where 1=1
66
67 <if test="username!=null">
68 and username like '%${username}%'
69 </if>
70 limit ${index},${pageSize}
71 </select>
72
73 <select id="countUser" parameterType="java.util.Map" resultType="int">
74 select count(*) from t_user where 1=1
75 <if test="username != null">
76 and username like '%${username}%'
77 </if>
78 </select>
79
80
81 </mapper>
#在生成SQL时，对于字符类型参数，会拼装引号
$在生成SQL时，不会拼装引号，可用于order by之类的参数拼装
测试类
1 package com.cy.mybatis.service;
2
3 import java.util.ArrayList;
4 import java.util.HashMap;
5 import java.util.List;
6 import java.util.Map;
7
8 import org.apache.ibatis.session.SqlSession;
9
10 import com.cy.mybatis.beans.UserBean;
11 import com.cy.mybatis.tools.DBTools;
12 import com.cy.mybatis.mapper.UserMapper;
13
14 public class UserService {
15
16 /**
17 * @param args
18 */
19 public static void main(String[] args) {
20 // insertUser();
21 // deleteUser();
22 // updateUser();
23 // selectUserById();
24 // selectAllUser();
25
26 // batchInsertUser();
27 // batchDeleteUser();
28 // countUser();
29 pagerUser();
30 }
31
32
33 private static void countUser() {
34 SqlSession session = DBTools.getSession();
35 UserMapper mapper = session.getMapper(UserMapper.class);
36 Map<String,Object> params = new HashMap<String,Object>();
37 params.put("username", "kitty");
38 int index = 0;
39 params.put("index", index);//从第几页开始。mysql是从0开始的
40 params.put("pageSize", 5);//每页显示的数据条数
41 int count;
42 try {
43 count = mapper.countUser(params);
44 System.out.println(count);
45 } catch (Exception e) {
46 e.printStackTrace();
47 }
48
49 }
50
51
52 private static void pagerUser() {
53 SqlSession session = DBTools.getSession();
54 UserMapper mapper = session.getMapper(UserMapper.class);
55 Map<String,Object> params = new HashMap<String,Object>();
56 params.put("username", "kitty");
57 params.put("index", 0);//从第几页开始。mysql是从0开始的
58 params.put("pageSize", 5);//每页显示的数据条数
59 try {
60 List<UserBean> u = mapper.pagerUser(params);
61 for (UserBean userBean : u) {
62 System.out.println("--------"+userBean);
63 }
64 } catch (Exception e) {
65 e.printStackTrace();
66 }
67
68 }
69
70
71 private static void batchDeleteUser() {
72 SqlSession session = DBTools.getSession();
73 UserMapper mapper = session.getMapper(UserMapper.class);
74 List<Integer> ids = new ArrayList<Integer>();
75 for(int i = 4; i < 10; i ++){
76 ids.add(i);
77 }
78 try {
79 mapper.batchDeleteUser(ids);
80 session.commit();
81 } catch (Exception e) {
82 e.printStackTrace();
83 }
84
85 }
86
87
88 private static void batchInsertUser() {
89 SqlSession session = DBTools.getSession();
90 UserMapper mapper = session.getMapper(UserMapper.class);
91
92 List<UserBean> users = new ArrayList<UserBean>();
93 for(int i = 0; i < 10; i ++){
94 UserBean user = new UserBean("kitty"+i, "123456", 6000.0);
95 users.add(user);
96 }
97 try {
98 mapper.batchInsertUser(users);
99 session.commit();
100 } catch (Exception e) {
101 e.printStackTrace();
102 }
103 }
104
105
106 /**
107 * 新增用户
108 */
109 private static void insertUser() {
110 SqlSession session = DBTools.getSession();
111 UserMapper mapper = session.getMapper(UserMapper.class);
112 UserBean user = new UserBean("懿", "1314520", 7000.0);
113 try {
114 mapper.insertUser(user);
115 System.out.println(user.toString());
116 session.commit();
117 } catch (Exception e) {
118 e.printStackTrace();
119 session.rollback();
120 }
121 }
122
123
124 /**
125 * 删除用户
126 */
127 private static void deleteUser(){
128 SqlSession session=DBTools.getSession();
129 UserMapper mapper=session.getMapper(UserMapper.class);
130 try {
131 mapper.deleteUser(1);
132 session.commit();
133 } catch (Exception e) {
134 e.printStackTrace();
135 session.rollback();
136 }
137 }
138
139 /**
140 * 修改用户数据
141 */
142 private static void updateUser(){
143 SqlSession session=DBTools.getSession();
144 UserMapper mapper=session.getMapper(UserMapper.class);
145 UserBean user =new UserBean("小明", "111",6000.0);
146 try {
147 mapper.updateUser(user, 3);
148 session.commit();
149 } catch (Exception e) {
150 e.printStackTrace();
151 session.rollback();
152 }
153 }
154
155 /**
156 * 根据id查询用户
157 */
158 private static void selectUserById(){
159 SqlSession session=DBTools.getSession();
160 UserMapper mapper=session.getMapper(UserMapper.class);
161 try {
162 UserBean user= mapper.selectUserById(2);
163 System.out.println(user.toString());
164
165 session.commit();
166 } catch (Exception e) {
167 e.printStackTrace();
168 session.rollback();
169 }
170 }
171
172 /**
173 * 查询所有的用户
174 */
175 private static void selectAllUser(){
176 SqlSession session=DBTools.getSession();
177 UserMapper mapper=session.getMapper(UserMapper.class);
178 try {
179 List<UserBean> user=mapper.selectAllUser();
180 System.out.println(user.toString());
181 session.commit();
182 } catch (Exception e) {
183 e.printStackTrace();
184 session.rollback();
185 }
186 }
187
188 }
看一下项目的整体：
时间： 2024-09-20 05:47:50