学习Spring(5)整合MyBatis

朴灿烈づ我的快乐病毒、 2023-01-23 08:00 6阅读 0赞

# Spring整合MyBatis #

### mybatis基础 ###

maven：

<dependencies>
        
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.15.RELEASE</version>
        </dependency>
        
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>
        
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.4</version>
        </dependency>
        
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.1</version>
        </dependency>
        
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.6</version>
        </dependency>
    </dependencies>

还有一个问题，如果配到xml配置文件不起作用可以试试：

<build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.*</include>
                </includes>
                
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

#### mybatis流程： ####

1.  编写pojo实体类(表的对应类)
2.  实现mybatis的配置文件(表连接)
3.  接口编写(对表的操作接口，增删改查)
4.  接口对应的Mapper映射文件(接口和sql的映射xml)
5.  测试类

目录结构：

*  java
    
     *  com.test
        
         *  dao
            
             *  PlayerMapper.java(第三步的表操作接口)
         *  pojo
            
             *  Player.java(第一步的表对应类)
 *  resources
    
     *  com.test.mapper
        
         *  PlayerMapper.xml(第四步的映射文件配置)
     *  MyBatisConfig.xml(第二步的mybatis配置)
 *  test
    
     *  MyBatisTest.java(测试)

第一步：Player.java(先写表类)：

package com.test.pojo;
    import lombok.Data;
    // @Data 可以省去写get/set方法
    @Data
    // @NoArgsConstructor 添加一个无参构造，因为有一个带参数构造方法，这里需要一个无参数构造方法，不然查询会出问题
    // 为什么需要一个无参构造，因为mybatis框架会调用这个默认构造方法来构造实例对象，反射Class类的newInstance方法调用无参构造，所以没有会报错
    @NoArgsConstructor
    public class Player { 
        private int player_id;
        private int team_id;
        private String player_name;
        private float height;
        // 为了方便批量插入方便写的构造方法，因为映射中是根据id自增，所以这里不需要id
        public Player(int team_id, String player_name, float height){ 
            this.team_id = team_id;
            this.player_name = player_name;
            this.height = height;
        }
    }

第二步：MyBatisConfig.xml 配置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 >
        
        <settings>
            <setting name="logImpl" value="STDOUT_LOGGING" />
        </settings>
        
        <typeAliases>
            <package name="com.test.pojo"/>
        </typeAliases>
        <environments default="development">
            <environment id="development">
                
                <transactionManager type="JDBC"/>
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                    
                    <property name="url" value="jdbc:mysql://127.0.0.1:3306/test_crm?characterEncoding=utf-8"/>
                    <property name="username" value="root"/>
                    <property name="password" value="root123456"/>
                </dataSource>
            </environment>
        </environments>
        <mappers>
            
            
            <mapper resource="com/test/mapper/PlayerMapper.xml"/>
            
            
        </mappers>
    </configuration>

第三步：PlayerMapper.java 编写表操作接口：

package com.test.dao;
    import com.test.pojo.Player;
    import java.util.List;
    public interface PlayerMapper { 
        // 查询
        List<Player> selectPlayer(List<Integer> ids);
        // 新增，用int，插入成功后会显示条数
        int addPlayers(List<Player> players);
        // 更新
        int updatePlayer(List<Player> players);
    }

第四步：PlayerMapper.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="com.test.dao.PlayerMapper">
        
        
        
        <select id="selectPlayer" resultType="com.test.pojo.Player">
            select * from player where player_id in 
            <foreach collection="list" index="index" item="item" open="(" separator="," close=")">
                #{item}
            </foreach>
            ;
        </select>
        
        
    
        
        <insert id="addPlayers" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="player_id">
            INSERT INTO
            player(team_id,player_name, height)
            VALUES
            <foreach collection="list" item="item" index="index" separator="," >
                (#{item.team_id},#{item.player_name},#{item.height})
            </foreach>
        </insert>
        
        
        <update id="updatePlayer" parameterType="java.util.List">
            UPDATE player
            <trim prefix="set" suffixOverrides=",">
                <trim prefix="team_id =case" suffix="end,">
                    <foreach collection="list" item="item">
                        <if test="item.team_id!=null">
                            when player_id=#{item.player_id} then #{item.team_id}
                        </if>
                    </foreach>
                </trim>
                <trim prefix="player_name =case" suffix="end,">
                    <foreach collection="list" item="item">
                        <if test="item.player_name!=null">
                            when player_id=#{item.player_id} then #{item.player_name}
                        </if>
                    </foreach>
                </trim>
                <trim prefix="height =case" suffix="end,">
                    <foreach collection="list" item="item">
                        <if test="item.height!=null">
                            when player_id=#{item.player_id} then #{item.height}
                        </if>
                    </foreach>
                </trim>
            </trim>
            <where>
                <foreach collection="list" separator="or" item="item">
                    player_id=#{item.player_id}
                </foreach>
            </where>
        </update>
        
        
    </mapper>

第五步：MyBatisTest.java 测试：

import com.test.dao.PlayerMapper;
    import com.test.pojo.Player;
    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.Test;
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    public class MyBatisTest { 
        @Test
        public void  test() throws IOException { 
            //获得核心配置文件
            String resource = "MyBatisConfig.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            //获得session工厂对象
            // SqlSessionFactory相当于数据库连接池
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            // SqlSession 相当于一个数据库连接
            SqlSession sqlSession = sqlSessionFactory.openSession();
            //获取映射接口
            PlayerMapper mapper = sqlSession.getMapper(PlayerMapper.class);
            // 批量新增数据，因为是id自增所以这里不需要ID
            List<Player> playerList2 = new ArrayList<Player>(){ { 
                add(new Player(1001, "测试5", (float) 1.89));
                add(new Player(1002, "测试6", (float) 1.90));
                add(new Player(1001, "测试7", (float) 1.91));
                add(new Player(1002, "测试8", (float) 1.92));
            }};
            // 批量新增
            int succeedNum = mapper.addPlayers(playerList2);
            System.out.println(succeedNum);
            // 查询数据
            List<Player> playerList = mapper.selectPlayer(Arrays.asList(20036, 20037, 20038));
            for (Player player: playerList){ 
                // 修改数据
                player.setPlayer_name("修改"+player.getPlayer_name());
                player.setHeight(player.getHeight()-(float) 0.01);
            }
            // 批量更新数据
            int updateNum = mapper.updatePlayer(playerList);
            System.out.println("更新成功："+updateNum);
            // session 要提交
            sqlSession.commit();
            // 关闭资源
            sqlSession.close();
        }
    }

#### Spring 整合 MyBatis 方式一： ####

文档：[http://mybatis.org/spring/zh/index.html][http_mybatis.org_spring_zh_index.html]

要和 Spring 一起使用 MyBatis，需要在 Spring 应用上下文中定义至少两样东西：一个 SqlSessionFactory 和至少一个数据映射器类

所指定的映射器类必须是一个接口，而不是具体的实现类

在之前项目的流程上修改的流程：

1.  新增一个spring整合mybatis的配置文件，xml中配置DriverManagerDataSource，sqlSessionFactory，SqlSessionTemplate等，这样就省去之前的代码写sqlSessionFactory和SqlSession
2.  去掉之前mybatis中的多余配置内容，因为放到整合的配置文件中了，这个配置文件主要是拓展mybatis的一些配置
3.  再将整合的配置文件导入到spring配置文件applicationContext.xml(单独几个配置文件是为了灵活性)
4.  接口实现类，实例化，为什么需要实现类，因为spring ioc要接管实例对象SqlSessionTemplate，映射接口，sql操作方法
5.  去xml配置文件中注册实现类的bean
6.  测试

目录结构：

*  java
    
     *  com.test
        
         *  dao
            
             *  PlayerMapper.java
             *  PlayerMapperImpl.java(接口实现类)
         *  pojo
            
             *  Player.java
 *  resources
    
     *  com.test.mapper
        
         *  PlayerMapper.xml
     *  applicationContext.xml(spring配置文件)
     *  MyBatisConfig.xml
     *  spring-dao.xml(spring整合mybatis配置文件)
 *  test
    
     *  MyBatisTest.java(测试)

新增spring整合mybatis配置文件spring-dao.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 id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
            <property name="url" value="jdbc:mysql://127.0.0.1:3306/test_crm?characterEncoding=utf-8" />
            <property name="username" value="root" />
            <property name="password" value="root123456" />
        </bean>
        
        
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource" />
            
            <property name="mapperLocations" value="classpath:com/test/mapper/*.xml" />
            
            
            
            <property name="configLocation" value="MyBatisConfig.xml" />
        </bean>
        
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <constructor-arg ref="dataSource" />
        </bean>
        
        <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
            <constructor-arg index="0" ref="sqlSessionFactory" />
        </bean>
        
        <bean id="playerMapper" class="com.test.dao.PlayerMapperImpl">
            
            <property name="sqlSession" ref="sqlSession" />
        </bean>
    </beans>

去掉mybatis中不需要的配置内容MyBatisConfig.xml：

新增applicationContext.xml，spring配置文件：

新增接口实现类PlayerMapperImpl.java：

package com.test.dao;
    import com.test.pojo.Player;
    import org.mybatis.spring.SqlSessionTemplate;
    import java.util.List;
    public class PlayerMapperImpl implements PlayerMapper{ 
    
        // 从原来的SqlSession改为使用SqlSessionTemplate
        private SqlSessionTemplate sqlSession;
        // set方法设置sqlSession
        public void setSqlSession(SqlSessionTemplate sqlSession) { 
            this.sqlSession = sqlSession;
        }
        // get方法获取sqlSession
        public SqlSessionTemplate getSqlSession() { 
            return this.sqlSession;
        }
        // 映射接口
        public PlayerMapper getPlayerMapper(SqlSessionTemplate sqlSession){ 
            return sqlSession.getMapper(PlayerMapper.class);
        }
        // 查询
        @Override
        public List<Player> selectPlayer(List<Integer> ids) { 
            // 映射接口
            return getPlayerMapper(getSqlSession()).selectPlayer(ids);
        }
        // 新增
        @Override
        public int addPlayers(List<Player> players) { 
            return getPlayerMapper(getSqlSession()).addPlayers(players);
        }
        // 更新
        @Override
        public int updatePlayer(List<Player> players) { 
            return getPlayerMapper(getSqlSession()).updatePlayer(players);
        }
    }

修改测试代码MyBatisTest.java：

import com.test.dao.PlayerMapper;
    import com.test.pojo.Player;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    public class MyBatisTest { 
        @Test
        public void  test(){ 
            // spring配置文件
            ApplicationContext application = new ClassPathXmlApplicationContext("applicationContext.xml");
            PlayerMapper mapper = application.getBean("playerMapper", PlayerMapper.class);
            List<Player> playerList2 = new ArrayList<Player>(){ { 
                add(new Player(1001, "测试15", (float) 1.89));
                add(new Player(1002, "测试16", (float) 1.90));
                add(new Player(1001, "测试17", (float) 1.91));
                add(new Player(1002, "测试18", (float) 1.92));
            }};
            // 新增
            mapper.addPlayers(playerList2);
            // 查询
            List<Player> playerList = mapper.selectPlayer(Arrays.asList(20036, 20037, 20038));
            playerList.forEach(System.out::println);
        }
    }

#### Spring 整合 MyBatis 方式二： ####

通过 SqlSessionDaoSupport，SqlSessionDaoSupport 是一个抽象的支持类，用来为你提供 SqlSession。调用 getSqlSession() 方法你会得到一个 SqlSessionTemplate，之后可以用于执行 SQL 方法

这个方式和第一种相比就是将xml中的SqlSessionTemplate配置移除，实现类继承SqlSessionDaoSupport类，使用getSqlSession()获取一个SqlSession再操作，然后到spring配置中注册这个实现类，set注入sqlSessionFactory

目录结构：

*  java
    
     *  com.test
        
         *  dao
            
             *  PlayerMapper.java
             *  PlayerMapperImpl.java
         *  pojo
            
             *  Player.java
 *  resources
    
     *  com.test.mapper
        
         *  PlayerMapper.xml
     *  applicationContext.xml(spring配置文件)
     *  MyBatisConfig.xml
     *  spring-dao.xml
 *  test
    
     *  MyBatisTest.java(测试)

修改实现类PlayerMapperImpl.java：

package com.test.dao;
    import com.test.pojo.Player;
    import org.mybatis.spring.support.SqlSessionDaoSupport;
    import java.util.List;
    // 继承SqlSessionDaoSupport
    public class PlayerMapperImpl extends SqlSessionDaoSupport implements PlayerMapper{ 
        // 映射接口
        public PlayerMapper getPlayerMapper(){ 
            // getSqlSession() 就是获取一个SqlSession
            return getSqlSession().getMapper(PlayerMapper.class);
        }
        // 查询
        @Override
        public List<Player> selectPlayer(List<Integer> ids) { 
            // 映射接口
            return getPlayerMapper().selectPlayer(ids);
        }
        // 新增
        @Override
        public int addPlayers(List<Player> players) { 
            return getPlayerMapper().addPlayers(players);
        }
        // 更新
        @Override
        public int updatePlayer(List<Player> players) { 
            return getPlayerMapper().updatePlayer(players);
        }
    }

修改spring-dao.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 id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
            <property name="url" value="jdbc:mysql://127.0.0.1:3306/test_crm?characterEncoding=utf-8" />
            <property name="username" value="root" />
            <property name="password" value="root123456" />
        </bean>
        
        
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource" />
            
            <property name="mapperLocations" value="classpath:com/test/mapper/*.xml" />
            
            
            
            <property name="configLocation" value="MyBatisConfig.xml" />
        </bean>
        
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <constructor-arg ref="dataSource" />
        </bean>
        
        
        
        
        <bean id="playerMapper" class="com.test.dao.PlayerMapperImpl">
            
            <property name="sqlSessionFactory" ref="sqlSessionFactory" />
        </bean>
    </beans>

### 事务 ###

#### spring中的事务管理 ####

*  声明式事务：AOP
 *  编程式事务：代码中进行管理事务

目录结构：

*  java
    
     *  com.test
        
         *  dao
            
             *  PlayerMapper.java
             *  PlayerMapperImpl.java
         *  pojo
            
             *  Player.java
 *  resources
    
     *  com.test.mapper
        
         *  PlayerMapper.xml
     *  applicationContext.xml
     *  MyBatisConfig.xml
     *  SpringMyBatis.xml
 *  test
    
     *  MyBatisTest.java(测试)

流程：

1.  先创建表类
2.  sql操作的Mapper接口
3.  Mapper接口实现类
4.  编写映射xml
5.  编写mybatis配置文件
6.  编写spring整合mybatis配置文件
7.  编写spring配置文件
8.  测试

第一步：编写类Player.java：

package com.test.pojo;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class Player { 
        private int player_id;
        private int team_id;
        private String player_name;
        private float height;
        public Player(int team_id, String player_name, float height){ 
            this.team_id = team_id;
            this.player_name = player_name;
            this.height = height;
        }
    }

第二步：sql操作的Mapper接口PlayerMapper.java：

package com.test.dao;
    import com.test.pojo.Player;
    public interface PlayerMapper { 
        // 查询
        Player selectPlayer(int ids);
        // 新增，用int，插入成功后会显示条数
        int addPlayer(Player player);
        // 更新
        int updatePlayer(Player player);
    }

第三步：Mapper接口实现类PlayerMapperImpl.java：

package com.test.dao;
    import com.test.pojo.Player;
    import org.mybatis.spring.support.SqlSessionDaoSupport;
    public class PlayerMapperImpl extends SqlSessionDaoSupport implements PlayerMapper{ 
        // 映射接口
        public PlayerMapper getPlayerMapper(){  return getSqlSession().getMapper(PlayerMapper.class); }
        // 查询
        @Override
        // @Transactional(rollbackFor = Throwable.class) 这是注解形式的事务管理
        public Player selectPlayer(int ids) { 
            // 将几个操作放在一个方法里测试事务，要么一起成功，要么一起失败
            Player p = getPlayerMapper().selectPlayer(ids);
            p.setPlayer_name("bbbb");
            getPlayerMapper().updatePlayer(p);
            getPlayerMapper().addPlayer(new Player(1001, "测试20", (float) 1.89));
            return getPlayerMapper().selectPlayer(ids);
        }
        // 新增
        @Override
        public int addPlayer(Player player) { 
            return getPlayerMapper().addPlayer(player);
        }
        // 更新
        @Override
        public int updatePlayer(Player player) { 
            return getPlayerMapper().updatePlayer(player);
        }
    }

第四步：编写映射xml，PlayerMapper.xml：

第五步：编写mybatis配置文件，MyBatisConfig.xml：

第六步：编写spring整合mybatis配置文件，SpringMyBatis.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:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
        
        <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
            <property name="url" value="jdbc:mysql://127.0.0.1:3306/test_crm?characterEncoding=utf-8" />
            <property name="username" value="root" />
            <property name="password" value="root123456" />
        </bean>
        
        
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource" />
            
            <property name="mapperLocations" value="classpath:com/test/mapper/*.xml" />
            
            
            
            <property name="configLocation" value="MyBatisConfig.xml" />
        </bean>
        
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <constructor-arg ref="dataSource" />
        </bean>
        
        
        
        <tx:advice id="txAdvice" transaction-manager="transactionManager">
            <tx:attributes>
                
                
                <tx:method name="add*" propagation="REQUIRED"/>
                <tx:method name="delete*" propagation="REQUIRED"/>
                <tx:method name="update*" propagation="REQUIRED"/>
                <tx:method name="select*" propagation="REQUIRED"/>
                
                
                
                 <tx:method name="*" propagation="REQUIRED"/>
            </tx:attributes>
        </tx:advice>
        
        <aop:config>
            <aop:pointcut id="txPointcut" expression="execution(* com.test.dao.*.*(..))"/>
            <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
        </aop:config>
        
        <bean id="playerMapper" class="com.test.dao.PlayerMapperImpl">
            
            <property name="sqlSessionFactory" ref="sqlSessionFactory" />
        </bean>
    </beans>

第七步：编写spring配置文件，applicationContext.xml：

第八步：测试，MyBatisTest.java：

import com.test.dao.PlayerMapper;
    import com.test.pojo.Player;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    public class MyBatisTest { 
        @Test
        public void  test(){ 
            // spring配置文件
            ApplicationContext application = new ClassPathXmlApplicationContext("applicationContext.xml");
            PlayerMapper mapper = application.getBean("playerMapper", PlayerMapper.class);
            // 查询
            Player playerList = mapper.selectPlayer(20036);
        }
    }

[http_mybatis.org_spring_zh_index.html]: http://mybatis.org/spring/zh/index.html