Spring+Mybatis的整合

spring整合mybatis

1.需要把sqlsession对象交给spring的IOC容器管理，就可以进行mybatis的操作；

2.两个框架做整合需要依赖mybatis-spring.jar,这个jar包是由mybatis提供；

将 MyBatis 与 Spring 进行整合，主要解决的问题就是将 SqlSessionFactory 对象交由 Spring 来管理。所以，该整合，只需要将 SqlSessionFactory 的对象生成器 SqlSessionFactoryBean 注册在 Spring 容器中，再将其注入给 Dao 的实现类即可完成整合。实现 Spring 与 MyBatis 的整合常用的方式：扫描的 Mapper 动态代理 Spring 像插线板一样，mybatis 框架是插头，可以容易的组合到一起。插线板 spring 插上 mybatis，两个框架就是一个整体。 

使用mybatis，需要创建mybatis框架中的某些对象，使用这些对象，就可以使用mybatis提供的功能了。

对于mybatis执行sql语句，需要用到的对象有：

• SqlSessionFactory对象，只有创建了SqlSessionFactory对象，才能调用openSession()方法得到SqlSession对象。
• dao接口的代理对象，例如UserDao接口，需要的代理对象为：SqlSeesion.getMapper(UserDao.class)。
• 数据源DataSource对象，使用一个更强大、功能更多的连接池对象代替mybatis自己的PooledDataSource。
   

代码整理 

1、使用Navicat创建数据库和表

-- 判断存在即删除数据库
drop database if exists mydb;
-- 创建数据库
create database mydb;
-- 使用数据库
use mydb;
-- 删除重复的表
drop table if exists t_user;
#创建表
create table t_user(
uid int(11) primary key not null AUTO_INCREMENT,
username varchar(20),
birthday varchar(20),
sex varchar(5),
address varchar(50)
);

#插入数据
insert into t_user values (1, '张三', '2022-05-03', '男', '北京');
insert into t_user values (2, '李四', '2022-05-19', '男', '广州');
insert into t_user values (3, '小红', '2022-05-19', '女', '郑州');
insert into t_user values (4, '小美', '2022-05-20', '女', '郑州');

select * from t_user;

2、创建一个Module项目并导入jar包

bean层用于存储数据，对应数据库内每张表的字段以及其他需要的业务功能；

dao层用于操作数据库的，每个dao对应数据库一张表；

service层是业务逻辑层，负责对业务进行逻辑处理，对数据进行加工和封装；

servlet层是JavaWeb 中的 Servlet 是一种用于生成动态网页的 Java 程序，是 JavaWeb 开发的核心。Servlet 接收客户端的请求，处理请求，并返回响应。

lib导入jar包；test用于测试；

3、在bean层创建与表对照的实体类User并使用Setter、Getter和toString进行封装

public class User {
    //属性
    private Integer uid;
    private String username;
    private String birthday;
    private String sex;
    private String address;

    //方法
    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
    
    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", username='" + username + '\'' +
                ", birthday='" + birthday + '\'' +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

4、在dao层创建接口

@Repository和@Controller、@Service、@Component的作用差不多，都是把对象交给spring管理。@Repository用在持久层的接口上，这个注解是将接口的一个实现类交给spring管理。

@Repository
public interface UserDao {
    @Select("select * from t_user")
    List<User> selectAll();

    @Insert("insert into t_user(username,birthday,sex,address) values (#{username}, #{birthday},#{sex}, #{address})")
    int add(User user);

    @Delete("delete from t_user where uid = #{uid};")
    int delete(int uid);

    @Update("update t_user set username = #{username},birthday=#{birthday},sex= #{sex},address=#{address} where uid =#{uid};")
    int update(User user);
}

 5、在service层创建接口和实现类

public interface UserService {
    List<User> findAll();
    int insert(User user);
    int del(int uid);
    int upd(User user);
}

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    UserDao userDao;
    @Override
    public List<User> findAll() {
        return userDao.selectAll();
    }

    @Override
    public int insert(User user) {
        return userDao.add(user);
    }

    @Override
    public int del(int uid) {
        return userDao.delete(5);
    }

    @Override
    public int upd(User user) {
        return userDao.update(user);
    }
}

 6、spring配置文件和mybatis配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
	   http://www.springframework.org/schema/context/spring-context.xsd">
    <!--所有自己书写的类对象都交给IOC容器管理-->
    <context:component-scan base-package="com.zhan"/>
    <!--加载外部配置文件-->
    <context:property-placeholder location="jdbc.properties"/>
    <!--1.配置数据库连接的数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="Url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!--2.配置mybatis的SqlSessionFactory，自动获得核心对象SqlSession对象,可以自动-->
    <bean id="factoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--引用数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--加载mybatis的核心配置文件-->
        <property name="configLocation" value="mybatis.xml"/>
        <!--给实体类起别名-->
        <property name="typeAliasesPackage" value="com.zhan.bean"/>
        <!--开启缓存-->
<!--        <property name="cache" value="true"/>-->
    </bean>
    <!--3.配置mapper映射器，告诉mybatis要创建哪些接口的代理对象-->
    <bean id="scannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.zhan.dao"/>
    </bean>
</beans>

1.声明数据源 

2.注册SqlSessionFactoryBean

代替如下代码 

3.定义Mapper扫描配置器MapperScannerConfigurer

<?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.配置mybatis的运行 此处配置运行时使用log4j-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>

</configuration>

7、 在servlet层创建测试类

public class UserServlet {
    UserService userService;
    @Test
    public void testSelectAll() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        userService = context.getBean(UserService.class);
        List<User> userList = userService.findAll();
        for (User user : userList) {
            System.out.println(user);
        }
        /**
         * 新增
         */
        User user = new User();
        user.setUsername("王五");
        user.setBirthday("2023-4-6");
        user.setSex("男");
        user.setAddress("开封");
        int insert = userService.insert(user);
        System.out.println(insert);

        /**
         * 删除
         */
        int i = userService.del(5);
        System.out.println(i);
        /**
         * 修改
         */
        User user1 = new User();
        user1.setUid(5);
        user1.setUsername("赵六");
        user1.setBirthday("2023-4-7");
        user1.setSex("女");
        user1.setAddress("洛阳");
        int i1 = userService.upd(user1);
        System.out.println(i1);
    }
}

日志打印 

Aop操作补充

@Component
@Aspect
public class Active {
    @Before("execution(* com.zhan.service.impl.*.*(..))")
    public void check(){
        System.out.println("程序进行权限检查...");
    }
}

spring.xml补充配置 

<aop:aspectj-autoproxy/>

 

纯注解整合

Spring整合MyBatis注解版是指在Spring框架中使用MyBatis注解来进行持久化操作。这种方式相对于XML配置方式更加简洁，易于维护。在整合过程中，需要在Spring配置文件中配置数据源、事务管理器、Mapper扫描器等相关信息，同时在Mapper接口上使用注解来定义SQL语句。整合完成后，可以通过Spring的依赖注入来获取Mapper接口实例，从而进行数据库操作。

1.创建项目并导入jar包，创建实体类

2.接口和实现类

 

 

3.创建一个配置类代替配置文件

创建一个配置类（也就是使用 @Configuration 注解标注的类），在这个配置类中进行 Mybatis 的相关配置，例如：SqlSessionFactoryBean 的声明、数据源、Mapper 映射文件的位置、实体类别名等配置；

在基础的 MyBatis 中，通过 SqlSessionFactoryBuilder 创建 SqlSessionFactory，而在 MyBatis-Spring 中，则使用 SqlSessionFactoryBean 创建 SqlSessionFactory。

@Configuration注解用于设定当前类为配置类

@ComponentScan注解用于设定扫描路径，此注解只能添加一次，多个数据请用数组格式

@Configuration
@ComponentScan("com.zhan")
public class SpringConfig {
    //定义一个方法，创建对应的对象，然后给对象的属性赋值，最后使用@Bean交给IOC管理该对象
    @Bean
    public DataSource getDataSource(){
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
        dataSource.setUser("root");
        dataSource.setPassword("root");
        return dataSource;
    }
    //SqlSessionFactoryBean需要引用DataSource,直接在方法中定义参数，IOC会自动把上面定义的匹配对象注入
    @Bean
    public SqlSessionFactoryBean getSqlSessionFactoryBean(DataSource dataSource){
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        return factoryBean;

    }
    @Bean
    public MapperScannerConfigurer getScannerConfigurer(){
        MapperScannerConfigurer scannerConfigurer = new MapperScannerConfigurer();
        scannerConfigurer.setBasePackage("com.zhan.dao");
        return scannerConfigurer;
    }
}

4.测试

public class Test01 {
    UserService userService;
    @Test
    public void testSelectAll() {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        userService = context.getBean(UserService.class);
        List<User> userList = userService.findAll();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

日志打印