• 第二章 MyBatis入门

    1.Junit的使用

            在maven中导入junit依赖：

    1.     <dependency>
    2.       <groupId>junitgroupId>
    3.       <artifactId>junitartifactId>
    4.       <version>4.11version>
    5.       <scope>testscope>
    6.     dependency>

    注解的用法： 

    @Test:表示一个可以独立运行的单元测试方法；

    @Before:在每个单元测试方法执行之前运行;

    @After：在每个单元测试方法之后运行；

    @BeforeClass:使用该注解的方法必须是静态方法，会在所有单元测试方法运行之前执行一次；

    @AfterClass:必须是静态方法，会在所有单元测试方法之后运行一次。

     2. MyBatis

    2.1 ORM思想

            ORM(对象关系映射 Object Relational Mapping)是通过描述对象和数据库之间映射的元数据，将程序中的对象自动持久化到关系数据库中。

    通过自定义注解和反射实现简单的orm:

    自定义注解：

    1. import java.lang.annotation.ElementType;
    2. import java.lang.annotation.Retention;
    3. import java.lang.annotation.RetentionPolicy;
    4. import java.lang.annotation.Target;
    5.  
    6.  
    7. @Target(ElementType.FIELD)
    8. @Retention(RetentionPolicy.RUNTIME)
    9. public @interface ColumnInformation {
    10.     String colName();
    11.     String colType();
    12.     int colSize() default 20;
    13. }
    1. import java.lang.annotation.ElementType;
    2. import java.lang.annotation.Retention;
    3. import java.lang.annotation.RetentionPolicy;
    4. import java.lang.annotation.Target;
    5.  
    6.  
    7. @Target(ElementType.FIELD)
    8. @Retention(RetentionPolicy.RUNTIME)
    9. public @interface PrimaryKey {
    10.     boolean isAutoIncrement();
    11. }
    1. import java.lang.annotation.ElementType;
    2. import java.lang.annotation.Retention;
    3. import java.lang.annotation.RetentionPolicy;
    4. import java.lang.annotation.Target;
    5.  
    6. @Target(ElementType.TYPE)
    7. @Retention(RetentionPolicy.RUNTIME)
    8. public @interface Table {
    9.     String tableName();
    10. }

    给实体对象的添加注解：

    student：

    1. import com.wen.annotation.ColumnInformation;
    2. import com.wen.annotation.PrimaryKey;
    3. import com.wen.annotation.Table;
    4.  
    5. import java.util.Date;
    6.  
    7. @Table(tableName = "student")
    8. public class Student {
    9.     @PrimaryKey(isAutoIncrement = true)
    10.     @ColumnInformation(colName = "s_id",colType = "int",colSize = 11)
    11.     private Integer s_id;
    12.  
    13.     @ColumnInformation(colName = "s_name",colType = "varchar",colSize = 10)
    14.     private String s_name;
    15.  
    16.     @ColumnInformation(colName = "s_birth",colType = "date")
    17.     private Date s_birth;
    18.  
    19.     @ColumnInformation(colName = "s_sex",colType = "char",colSize = 1)
    20.     private String s_sex;
    21.  
    22.     public Student() {
    23.     }
    24.  
    25.     public Student(Integer s_id, String s_name, Date s_birth, String s_sex) {
    26.         this.s_id = s_id;
    27.         this.s_name = s_name;
    28.         this.s_birth = s_birth;
    29.         this.s_sex = s_sex;
    30.     }
    31.  
    32.     public Student(String s_name, Date s_birth, String s_sex) {
    33.         this.s_name = s_name;
    34.         this.s_birth = s_birth;
    35.         this.s_sex = s_sex;
    36.     }
    37.  
    38.     public Integer getS_id() {
    39.         return s_id;
    40.     }
    41.  
    42.     public void setS_id(Integer s_id) {
    43.         this.s_id = s_id;
    44.     }
    45.  
    46.     public String getS_name() {
    47.         return s_name;
    48.     }
    49.  
    50.     public void setS_name(String s_name) {
    51.         this.s_name = s_name;
    52.     }
    53.  
    54.     public Date getS_birth() {
    55.         return s_birth;
    56.     }
    57.  
    58.     public void setS_birth(Date s_birth) {
    59.         this.s_birth = s_birth;
    60.     }
    61.  
    62.     public String getS_sex() {
    63.         return s_sex;
    64.     }
    65.     public void setS_sex(String s_sex) {
    66.         this.s_sex = s_sex;
    67.     }
    68.  
    69.     @Override
    70.     public String toString() {
    71.         return "Student{" +
    72.                 "s_id=" + s_id +
    73.                 ", s_name='" + s_name + '\'' +
    74.                 ", s_birth=" + s_birth +
    75.                 ", s_sex='" + s_sex + '\'' +
    76.                 '}';
    77.     }
    78. }

    score：

    1. import com.wen.annotation.ColumnInformation;
    2. import com.wen.annotation.PrimaryKey;
    3. import com.wen.annotation.Table;
    4.  
    5.  
    6. @Table(tableName = "score")
    7. public class Score {
    8.     @PrimaryKey(isAutoIncrement = true)
    9.     @ColumnInformation(colName = "s_id",colType = "int",colSize = 20)
    10.     private Integer s_id;
    11.  
    12.     @ColumnInformation(colName = "c_id",colType = "int",colSize = 20)
    13.     private Integer c_id;
    14.  
    15.     @ColumnInformation(colName = "s_score",colType = "decimal",colSize = 3)
    16.     private Double s_score;
    17.  
    18.     public Score() {
    19.     }
    20.  
    21.     public Score(Integer s_id, Integer c_id, Double s_score) {
    22.         this.s_id = s_id;
    23.         this.c_id = c_id;
    24.         this.s_score = s_score;
    25.     }
    26.  
    27.     public Integer getS_id() {
    28.         return s_id;
    29.     }
    30.  
    31.     public void setS_id(Integer s_id) {
    32.         this.s_id = s_id;
    33.     }
    34.  
    35.     public Integer getC_id() {
    36.         return c_id;
    37.     }
    38.  
    39.     public void setC_id(Integer c_id) {
    40.         this.c_id = c_id;
    41.     }
    42.  
    43.     public Double getS_score() {
    44.         return s_score;
    45.     }
    46.  
    47.     public void setS_score(Double s_score) {
    48.         this.s_score = s_score;
    49.     }
    50.  
    51.     @Override
    52.     public String toString() {
    53.         return "Score{" +
    54.                 "s_id=" + s_id +
    55.                 ", c_id=" + c_id +
    56.                 ", s_score=" + s_score +
    57.                 '}';
    58.     }
    59. }

    orm实现：

    inteeface:

    1. import java.util.List;
    2. import java.util.Map;
    3.  
    4. public interface IGenericDao {
    5.     /**
    6.      * 查询全部数据
    7.      * @param t
    8.      * @return
    9.      */
    10.     List> listAll(T t);
    11.  
    12.     /**
    13.      * 插入数据
    14.      * @param t
    15.      * @return
    16.      */
    17.     int insert(T t);
    18.  
    19.     /**
    20.      * 修改数据
    21.      * @param t
    22.      * @return
    23.      */
    24.     int update(T t);
    25.  
    26.     /**
    27.      * 删除数据
    28.      * @param t
    29.      * @return
    30.      */
    31.     int delete(T t);
    32. }

    impl:

    1. import com.wen.annotation.ColumnInformation;
    2. import com.wen.annotation.PrimaryKey;
    3. import com.wen.annotation.Table;
    4. import com.wen.orm.dao.IGenericDao;
    5. import com.wen.orm.util.BaseDao;
    6.  
    7. import java.beans.IntrospectionException;
    8. import java.beans.PropertyDescriptor;
    9. import java.lang.reflect.Field;
    10. import java.lang.reflect.InvocationTargetException;
    11. import java.lang.reflect.Method;
    12. import java.util.List;
    13. import java.util.Map;
    14.  
    15.  
    16. public class GenericDaoImpl implements IGenericDao {
    17.     private String getSql(Class t,String sign) {
    18.         StringBuilder sql = new StringBuilder();
    19.         if(t.isAnnotationPresent(Table.class)){
    20.             Table table = (Table) t.getAnnotation(Table.class);
    21.             Field[] declaredFields = t.getDeclaredFields();
    22.  
    23.             StringBuilder colSql = new StringBuilder();
    24.  
    25.             int count = 0;
    26.             String colNameByPrimaryKey ="";
    27.             switch (sign){
    28.                 case "selectAll":
    29.                     sql.append("select ");
    30.                     for (Field f:declaredFields) {
    31.                         ColumnInformation annotation = f.getAnnotation(ColumnInformation.class);
    32.                         colSql.append(annotation.colName()+",");
    33.                     }
    34.                     sql.append(colSql.substring(0,colSql.length()-1)).append(" from ").append(table.tableName());
    35.                     break;
    36.                 case "insert":
    37.                     sql.append("insert into ");
    38.                     sql.append(table.tableName());
    39.                     sql.append("(");
    40.  
    41.                     for (Field f:declaredFields) {
    42.                         if(f.isAnnotationPresent(PrimaryKey.class)){
    43.                             continue;
    44.                         }
    45.                         ColumnInformation annotation = f.getAnnotation(ColumnInformation.class);
    46.                         colSql.append(annotation.colName()+",");
    47.                         count++;
    48.                     }
    49.                     sql.append(colSql.substring(0,colSql.length()-1));
    50.                     sql.append(") value (?");
    51.                     for (int i = 0; i < count-1; i++) {
    52.                         sql.append(",?");
    53.                     }
    54.                     sql.append(")");
    55.                     break;
    56.                 case "update":
    57.                     sql.append("update ");
    58.                     sql.append(table.tableName());
    59.                     sql.append(" set ");
    60.                     for (Field f:declaredFields) {
    61.                         ColumnInformation annotation = f.getAnnotation(ColumnInformation.class);
    62.                         if(f.isAnnotationPresent(PrimaryKey.class)){
    63.                             colNameByPrimaryKey = annotation.colName();
    64.                             continue;
    65.                         }
    66.                         colSql.append(annotation.colName()+"= ?,");
    67.                     }
    68.                     sql.append(colSql.substring(0,colSql.length()-1));
    69.                     sql.append(" where "+colNameByPrimaryKey+"= ?");
    70.                     break;
    71.                 case "delete":
    72.                     sql.append("delete from ");
    73.                     sql.append(table.tableName());
    74.                     for (Field f:declaredFields) {
    75.                         ColumnInformation annotation = f.getAnnotation(ColumnInformation.class);
    76.                         if(f.isAnnotationPresent(PrimaryKey.class)){
    77.                             colNameByPrimaryKey = annotation.colName();
    78.                             break;
    79.                         }
    80.                     }
    81.                     sql.append(" where "+colNameByPrimaryKey+"= ?");
    82.                     break;
    83.                 default:
    84.                     break;
    85.             }
    86.         }
    87.         return sql.toString();
    88.     }
    89.     @Override
    90.     public List> listAll(T t) {
    91.         String sql = getSql(t.getClass(),"selectAll");
    92.         System.out.println(sql);
    93.         return BaseDao.executeQuery(sql,null);
    94.     }
    95.  
    96.     @Override
    97.     public int insert(T t) {
    98.         Class aClass = t.getClass();
    99.         String sql = getSql(aClass,"insert");
    100.         System.out.println(sql);
    101.  
    102.         Field[] declaredFields = aClass.getDeclaredFields();
    103.         Object[] params  = new Object[declaredFields.length];
    104.         int i = 0;
    105.         for (Field field:declaredFields) {
    106.             if(field.isAnnotationPresent(PrimaryKey.class)){
    107.                 continue;
    108.             }
    109.             try {
    110.                 PropertyDescriptor propertyDescriptor = new PropertyDescriptor(field.getName(), aClass);
    111.                 Method readMethod = propertyDescriptor.getReadMethod();
    112.                 params[i++] = readMethod.invoke(t);
    113.             } catch (IntrospectionException e) {
    114.                 e.printStackTrace();
    115.             } catch (IllegalAccessException e) {
    116.                 e.printStackTrace();
    117.             } catch (InvocationTargetException e) {
    118.                 e.printStackTrace();
    119.             }
    120.         }
    121.         System.out.println(i);
    122.         Object[] newParams = new Object[i];
    123.         System.arraycopy(params,0,newParams,0,i);
    124.  
    125.         for (Object o :newParams) {
    126.             System.out.println(o);
    127.         }
    128.         return BaseDao.executeUpdate(sql,newParams);
    129.     }
    130.  
    131.     @Override
    132.     public int update(T t) {
    133.         Class aClass = t.getClass();
    134.         String sql = getSql(aClass,"update");
    135.         System.out.println(sql);
    136.  
    137.         Field[] declaredFields = aClass.getDeclaredFields();
    138.         Object oByPrimaryKey = "";
    139.         Object[] params = new Object[declaredFields.length];
    140.         int i = 0;
    141.         for (Field f:declaredFields) {
    142.             try {
    143.                 PropertyDescriptor propertyDescriptor = new PropertyDescriptor(f.getName(), aClass);
    144.                 if(f.isAnnotationPresent(PrimaryKey.class)){
    145.                     oByPrimaryKey = propertyDescriptor.getReadMethod().invoke(t);
    146.                 }else {
    147.                     params[i++] = propertyDescriptor.getReadMethod().invoke(t);
    148.                 }
    149.             } catch (IntrospectionException e) {
    150.                 e.printStackTrace();
    151.             } catch (IllegalAccessException e) {
    152.                 e.printStackTrace();
    153.             } catch (InvocationTargetException e) {
    154.                 e.printStackTrace();
    155.             }
    156.         }
    157.         params[i] = oByPrimaryKey;
    158.         for (Object o: params) {
    159.             System.out.println(o);
    160.         }
    161.         return BaseDao.executeUpdate(sql,params);
    162.     }
    163.  
    164.     @Override
    165.     public int delete(T t) {
    166.         Class aClass = t.getClass();
    167.         String sql = getSql(aClass,"delete");
    168.         System.out.println(sql);
    169.         Field[] declaredFields = aClass.getDeclaredFields();
    170.         Object[] params = null;
    171.         for (Field f:declaredFields) {
    172.             if(f.isAnnotationPresent(PrimaryKey.class)){
    173.                 try {
    174.                     params = new Object[]{new PropertyDescriptor(f.getName(),aClass).getReadMethod().invoke(t)};
    175.                 } catch (IllegalAccessException e) {
    176.                     e.printStackTrace();
    177.                 } catch (InvocationTargetException e) {
    178.                     e.printStackTrace();
    179.                 } catch (IntrospectionException e) {
    180.                     e.printStackTrace();
    181.                 }
    182.             }
    183.         }
    184.         System.out.println(params[0]);
    185.         return BaseDao.executeUpdate(sql,params);
    186.     }
    187. }

    测试：

    1. import com.wen.entity.Score;
    2. import com.wen.entity.Student;
    3. import com.wen.orm.dao.IGenericDao;
    4. import com.wen.orm.dao.impl.GenericDaoImpl;
    5.  
    6. import java.text.ParseException;
    7. import java.text.SimpleDateFormat;
    8. import java.util.List;
    9. import java.util.Map;
    10.  
    11. public class Test {
    12.     public static void main(String[] args) throws ParseException {
    13.         IGenericDao genericDao = new GenericDaoImpl();
    14.         Student student = new Student();
    15.         Score score = new Score(8,3,98.0);
    16.  
    17.         student.setS_id(15);
    18.         student.setS_name("小温");
    19.         student.setS_birth(new SimpleDateFormat("yyyy-MM-dd").parse("2008-1-1"));
    20.         student.setS_sex("男");
    21.  
    22.  
    23.        //genericDao.insert(student);
    24.         //genericDao.insert(score);
    25.         //genericDao.update(student);
    26.         genericDao.delete(student);
    27.  
    28.         //genericDao.delete(score);
    29.  
    30.         System.out.println("======================");
    31.         List> list = genericDao.listAll(student);
    32.         for (Map map:list) {
    33.             System.out.println(map);
    34.         }
    35.     }
    36. }

    2.2 MyBatis简介

            一个基于Java的持久层/数据访问层框架。

    2.3 结构

    ①接口层：给应用程序提供一系列的数据接口；

    ②接口层传递参数：sql命令，在数据处理曾进行处理，返回对应的结果映射；

    ③基础支撑层：提供最基础的底层的操作：连接管理(连接池),事务管理(增、删、该)，配置加载(读取配置信息)，缓存(一级缓存，二级缓存)

    2.4 环境搭建 

    整体结构：

     

            Mybatis官网：mybatis – MyBatis 3 | 入门

    ①建立maven项目，导入需要的jar包；

            pom.xml：

    1.     <dependency>
    2.       <groupId>org.mybatisgroupId>
    3.       <artifactId>mybatisartifactId>
    4.       <version>3.5.7version>
    5.     dependency>
    6.     <dependency>
    7.       <groupId>mysqlgroupId>
    8.       <artifactId>mysql-connector-javaartifactId>
    9.       <version>8.0.11version>
    10.     dependency>
    11.     <dependency>
    12.       <groupId>junitgroupId>
    13.       <artifactId>junitartifactId>
    14.       <version>4.11version>
    15.       <scope>testscope>
    16.     dependency>

    ②创建配置数据库连接信息的properties文件；

            db.properties：

    1. jdbc.driver = com.mysql.cj.jdbc.Driver
    2. jdbc.url = jdbc:mysql://127.0.0.1:3306/***?useSSL=false&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    3. jdbc.userName = 
    4. jdbc.password =

    ③配置数据库连接属性和mybati日志；

    Mybatis.xml:

    配置文件的属性是有序的，顺序不对会直接报错；

    2. configuration
    3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
    5. <configuration>
    6.     
    7.     <properties resource="db.properties">
    8.  
    9.     properties>
    10.     <settings>
    11.         
    12.         <setting name="logImpl" value="STDOUT_LOGGING" />
    13.         
    14.         <setting name="mapUnderscoreToCamelCase" value="true"/>
    15.     settings>
    16.     <typeAliases>
    17.         
    18.         <typeAlias type="com.entity.Goods" alias="Goods"/>
    19.         
    20.         <package name="com.entity"/>
    21.     typeAliases>
    22.     <environments default="development">
    23.         <environment id="development">
    24.             <transactionManager type="JDBC"/>
    25.             <dataSource type="POOLED">
    26.                 <property name="driver" value="${jdbc.driver}"/>
    27.                 <property name="url" value="${jdbc.url}"/>
    28.                 <property name="username" value="${jdbc.userName}"/>
    29.                 <property name="password" value="${jdbc.password}"/>
    30.             dataSource>
    31.         environment>
    32.     environments>
    33.     
    34.     <mappers>
    35.         
    36.         
    37.         <mapper class="com.mapper.GoodsMapper"/>
    38.  
    39.         
    40.     mappers>
    41.     
    42. configuration>

    ④在mapper包下创建对应实体的mapper接口(GoodsMapper.java)

     

    1. import com.entity.Goods;
    2. import com.entity.PageInfo;
    3.  
    4. import java.util.List;
    5. import java.util.Map;
    6.  
    7. public interface GoodsMapper {
    8.     /**
    9.      * 两表查询，包含商品种类
    10.      * @return
    11.      */
    12.     List goodsList();
    13.  
    14.     /**
    15.      * goods集合
    16.      * @return
    17.      */
    18.     List listAllGoods();
    19.  
    20.     /**
    21.      * 带分页的两表查询，含商品分类
    22.      * pageInfo
    23.      * @return
    24.      */
    25.     List goodsListByPage(PageInfo pageInfo);
    26.  
    27.     /**
    28.      * 可一次插入多条商品记录
    29.      * @param goodsList
    30.      * @return
    31.      */
    32.     int insertGoods(List goodsList);
    33.  
    34.     /**
    35.      * 单商品修改
    36.      * @param goods
    37.      * @return
    38.      */
    39.     int updateGoods(Goods goods);
    40.  
    41.     /**
    42.      * 单商品删除
    43.      * @param goodsId
    44.      * @return
    45.      */
    46.     int deleteGoods(int goodsId);
    47.  
    48.     /**
    49.      * 删库，重置自增列
    50.      * @return
    51.      */
    52.     int cleanTable();
    53. }

    ⑤在mapper包下创建对应实体的mapper文件(GoodsMapper.xml)

    采用mapper接口开发的方式时，要注意：

    ①配置文件和其对应的接口，除了文件类型不同，其他的完全相同；

    ②resources中创建多级目录要用“/”来分割，不能用“.”；

    ③xml文件中对应的查询语句的"id"要与对应接口的方法名完全一致;

    ④返回的结果的类型或参数的类型，如果是自己创建的类型需要写完整，或者在MyBatis.xml中配置好别名；

    ⑤在sql语句中有多个参数时，名称要与传入的一致。

    2. mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5.  
    6. <mapper namespace="com.mapper.GoodsMapper">
    7.     <select id="goodsList" resultType="map">
    8.         select goods_id,goods_name,price,produce_date,address,categoryName
    9.         from tb_goods,category
    10.         where tb_goods.category_id = category.categoryId
    11.     select>
    12.  
    13.     <select id="listAllGoods" resultType="Goods">
    14.         select goodsId,goodsName,price,produceDate,address,categoryId from goods
    15.     select>
    16.  
    17.     <select id="goodsListByPage" resultType="map" parameterType="com.entity.PageInfo">
    18.         select goods_id,goods_name,price,produce_date,address,category_id,categoryName
    19.         from tb_goods,category
    20.         where tb_goods.category_id = category.categoryId
    21.         order by goods_id
    22.         limit #{page},#{limit}
    23.     select>
    24.     <insert id="insertGoods" parameterType="java.util.ArrayList">
    25.         insert into tb_goods(goods_name,price,produce_date,address,category_id)
    26.         values
    27.        <foreach collection="list" item="goods" index="index" separator=",">
    28.            (#{goods.goodsName}, #{goods.price}, #{goods.produceDate}, #{goods.address}, #{goods.categoryId})
    29.        foreach>
    30.  
    31.     insert>
    32.     <delete id="deleteGoods">
    33.         delete from tb_goods where goods_id = #{id}
    34.     delete>
    35.     <delete id="cleanTable">
    36.         truncate tb_goods;
    37.     delete>
    38. mapper>

    ⑥ 使用mybatis完成crud

    1. import com.dao.IGoodsDao;
    2. import com.entity.Goods;
    3. import com.entity.PageInfo;
    4. import com.mapper.GoodsMapper;
    5. import org.apache.ibatis.io.Resources;
    6. import org.apache.ibatis.session.SqlSession;
    7. import org.apache.ibatis.session.SqlSessionFactory;
    8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    9.  
    10. import java.io.IOException;
    11. import java.io.InputStream;
    12. import java.util.List;
    13. import java.util.Map;
    14.  
    15. public class GoodsDaoImpl implements IGoodsDao {
    16.     /**
    17.      * 创建一个SqlSession的工厂用于创建sqlSession对象
    18.      */
    19.     private static SqlSessionFactory sessionFactory;
    20.     static{
    21.         try {
    22.             InputStream resourceAsStream = Resources.getResourceAsStream("Mybatis.xml");
    23.             sessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    24.  
    25.         } catch (IOException e) {
    26.             e.printStackTrace();
    27.         }
    28.     }
    29.     @Override
    30.     public List goodsList() {
    31.         SqlSession sqlSession = sessionFactory.openSession(true);
    32.         GoodsMapper mapper = sqlSession.getMapper(GoodsMapper.class);
    33.         List goodsList = mapper.goodsList();
    34.         sqlSession.close();
    35.         return goodsList;
    36.     }
    37.  
    38.     @Override
    39.     public PageInfo goodsListByPage(int page, int limit) {
    40.  
    41.         PageInfo pageInfo = new PageInfo();
    42.         pageInfo.setPage((page-1)*limit);
    43.         pageInfo.setLimit(limit);
    44.         pageInfo.setTotalCount(goodsList().size());
    45.         pageInfo.setTotalPage();
    46.  
    47.  
    48.         SqlSession sqlSession = sessionFactory.openSession(true);
    49.         GoodsMapper mapper = sqlSession.getMapper(GoodsMapper.class);
    50.         List goodsList = mapper.goodsListByPage(pageInfo);
    51.         sqlSession.close();
    52.         pageInfo.setData(goodsList);
    53.         return pageInfo;
    54.     }
    55.  
    56.  
    57.     @Override
    58.     public int updateGoods(Goods goods) {
    59.         SqlSession sqlSession = sessionFactory.openSession(true);
    60.         GoodsMapper mapper = sqlSession.getMapper(GoodsMapper.class);
    61.         int count = mapper.updateGoods(goods);
    62.         sqlSession.close();
    63.         return count;
    64.     }
    65.  
    66.     @Override
    67.     public int deleteGoods(int goodsId) {
    68.         SqlSession sqlSession = sessionFactory.openSession(true);
    69.         GoodsMapper mapper = sqlSession.getMapper(GoodsMapper.class);
    70.         int count = mapper.deleteGoods(goodsId);
    71.         sqlSession.close();
    72.         return count;
    73.     }
    74.  
    75.     @Override
    76.     public int insertGoodsList(List goodsList) {
    77.         SqlSession sqlSession = sessionFactory.openSession(true);
    78.         GoodsMapper mapper = sqlSession.getMapper(GoodsMapper.class);
    79.         int count = mapper.insertGoods(goodsList);
    80.         sqlSession.close();
    81.         return count;
    82.     }
    83.  
    84.     @Override
    85.     public int resetTable() {
    86.         SqlSession sqlSession = sessionFactory.openSession(true);
    87.         GoodsMapper mapper = sqlSession.getMapper(GoodsMapper.class);
    88.         mapper.cleanTable();
    89.         int count = mapper.insertGoods(mapper.listAllGoods());
    90.         sqlSession.close();
    91.         return count;
    92.     }
    93. }

     ⑦mybatis的事务

    mybatis默认情况下是手动事务，在进行增删改操作之后要提交事务：

    ①提交：sqlSession.commit();

    ②设置自动事务:

            在MyBatis.xml中，修改transactionManager配置为：         

                    
                          
                

            创建sqlSession时，openSession()设置为true,默认为false：              

                    sessionFactory.openSession(true)。

  • 相关阅读:
    Swing程序设计详解（一）
    同步锁synchronized追本溯源
    Util应用框架 UI 开发快速入门
    【使用 BERT 的问答系统】第 6 章 ：BERT 模型应用：其他任务
    AM@第二类换元法积分
    Java毕设项目飞机订票管理系统计算机（附源码+系统+数据库+LW）
    MySQL字符集设置、密码管理
    AWS Lambda Golang HelloWorld 快速入门
    只有将公链无币化，才能支撑传统业务应用场景
    Python-Pychram使用
  • 原文地址：https://blog.csdn.net/m0_71674778/article/details/126335523