mybatis如何和spring组合使用

mybatis和spring一起组合使用,把这个两个框架组合到一起就像是使用同一个框架一样,让你更加专注自己的业务逻辑.

实现步骤:
1.新建maven项目 导入依赖 并且建立好对应的包名,创建数据库表,
创建好,各种配置文件,具体操作如下:

1.1项目整个项目的目录结构:

1.2maven配置文件依赖

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.bjpowernode</groupId>
	<artifactId>ch07-ssm</artifactId>
	<version>1.0-SNAPSHOT</version>
	<packaging>war</packaging>


	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<maven.compiler.source>1.8</maven.compiler.source>
		<maven.compiler.target>1.8</maven.compiler.target>
	</properties>

	<dependencies>
		<!--   单元测试  -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.11</version>
			<scope>test</scope>
		</dependency>


		<!-- spring依赖 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>5.2.5.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>5.2.5.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>5.2.5.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-core</artifactId>
			<version>2.9.0</version>
		</dependency>

		<!--mybatis和spring整合依赖-->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.3.1</version>
		</dependency>
		<dependency>
			<!--   mybatis依赖     -->
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.5.1</version>
		</dependency>
		<!--    mysql依赖    -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>8.0.21</version>
		</dependency>

		<!--  德鲁伊连接池  -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.12</version>
		</dependency>
	</dependencies>

	<build>
		<resources>
			<resource>
				<directory>src/main/java</directory><!--所在的目录-->
				<includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
					<include>**/*.properties</include>
					<include>**/*.xml</include>
				</includes>
				<filtering>false</filtering>
			</resource>
		</resources>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

1.3 applicationContext.xml文件的创建

这个文件的作用可就大了,他的作用就是
1.,读取到你的jdbc配置文件里面的内容,
2.配置数据库连接池,也就是得到Connection对象
3.把数据库连接池得到的对象赋值给dataSource对象
4.创建UserDao接口的对象
5.然后就是创建userService对象
这些关键的对象都创建好了,我只需要调用就可以了,spring就是用了管理我们的对象的,让我们不用关心对象是如何创建的,我们只需要使用spring框架创建出来的对象就可以了.

<?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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
      http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
      http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
">
<!-- 开启组件扫描 可以使用注解开发   -->
    <context:component-scan base-package="com.maven.spring"> </context:component-scan>


<!--  指定外部jdbc配置文件的路径  -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

<!--配置数据库连接池-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClassName" value="${jdbc.drivers}"/>
        <property name="maxActive" value="${jdbc.maxActive}"/>
    </bean>

<!-- mybatis 中所提供的的sqlSessionBean类 这个类内部是创建sqlSessionFactory对象的 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--  mybatis注入 把数据库连接池赋值给dataSource对象 -->
        <property name="dataSource" ref="myDataSource"></property>
<!--  把mybatis主配置文件注入给configLocation对象 用于去读取mybatis主配置文件的-->
        <property name="configLocation" value="classpath:mybatis.xml"> </property>
    </bean>

<!--创建dao对象 在内部去调用getMapper 生成每个dao接口的代理对象  -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!-- 指定sqlSessionFactory对象的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"> </property>
<!-- 指定一个包名 指定dao接口的包名 扫描这个包中的所有接口 得到每个dao接口的对象 把创建好的对象放到spring容器中 -->
        <property name="basePackage" value="com.maven.spring.dao"></property>
    </bean>

<!--  创建service对象  -->
    <bean id="userService"  class="com.maven.spring.service.Impl.UserServiceImpl">
        <property name="userDao" ref="userDao"> </property>
    </bean>


</beans>

1.4mybatis.xml主配置文件

mybatis.xml这个文件的主要作用就是让mybatis框架能够读取到你dao里面mapper文件的sql语句.

说白了,就是这个文件里面的sql语句:

<?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.maven.spring.bean"/>
</typeAliases>

    <!-- sql mapper(sql映射文件)的位置-->
    <mappers>
      <package name="com.maven.spring.dao"/>
    </mappers>

</configuration>

1.5 jdbc配置文件

主要是把数据库连接信息都放在该文件中,方便我们后期修改
需要注意的是:mysql驱动如果是高版本的需要加上时区,而且driver的写法也会有所变化.

其实drivers这个不用写也可以,框架自动帮我们完成了,但是我这里为了清晰一点,还是写了.

只需要把下面对应的信息换为自己的就可以了.

jdbc.url=jdbc:mysql://localhost:3306/book?serverTimezone=GMT%2B8
jdbc.drivers=com.mysql.cj.jdbc.Driver
jdbc.username=root
jdbc.password=123456
jdbc.maxActive=20

1.6数据库表的创建

CREATE TABLE `user` (
  `user_id` int NOT NULL AUTO_INCREMENT,
  `username` varchar(255) DEFAULT NULL,
  `password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL,
  PRIMARY KEY (`user_id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=12126 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

2.创建好和数据库对应的实体类

实体类的属性名和数据库表的字段名最好一致,当然不一致也行,后面写sql语句的时候使用别名机制就行,否则查询的时候会反射异常,导致查询到的值,无法赋值给user对象.

我这里的话,就是不一致的,我写sql的时候指定了别名的.这样其实也挺好,因为有时候数据库的字段名和我们实体类的属性名不一致的情况很多,我们就可以使用别名机制进行解决.

public class User {
    
    
   private  String id;
   private String username;
   private String password;

    public String getId() {
    
    
        return id;
    }

    public void setId(String id) {
    
    
        this.id = id;
    }

    public String getUsername() {
    
    
        return username;
    }

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

    public String getPassword() {
    
    
        return password;
    }

    public void setPassword(String password) {
    
    
        this.password = password;
    }

    public User() {
    
    
    }

    public User(String id, String username, String password) {
    
    
        this.id = id;
        this.username = username;
        this.password = password;
    }

    @Override
    public String toString() {
    
    
        return "User{" +
                "id='" + id + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

3.创建dao接口和mapper文件
我这里为了方便,简洁,就写一个查询和添加的方法,无非就是增删改查,大同小异.如果需要执行其他操作,可以自行增加.

3.1UserDao接口

public interface UserDao  {
    
    
   /**
    * 添加一个user对象
    * @param user 需要传入一个user对象
    * @return 返回影响的行数
    */
   int add (User user);

   /**
    * 查询表中所有的用户信息,然后封装到List集合中
    * @return 返回一个装有user对象的List集合
    */
   List<User> selectUser();

}

3.2mapper文件(写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="com.maven.spring.dao.UserDao">

    <select id="selectUser" resultType="com.maven.spring.bean.User">
        select user_id as id ,username,password from user
    </select>

    <insert id="add" >
     insert into  user values(#{id},#{username},#{password})
     </insert>

</mapper>

4.创建service层的接口和实现类

4.1service层接口

public interface UserService {
    
    
    /**
     * 添加一个user对象
     * @param user 需要传入一个user对象
     * @return 返回影响的行数
     */
    int add (User user);

    /**
     * 查询表中所有的用户信息,然后封装到List集合中
     * @return 返回一个装有user对象的List集合
     */
    List<User> selectUser();
}

4.1service实现类

public class UserServiceImpl implements UserService {
    
    
    //引用类型
    private UserDao userDao;
     //spring框架使用set方法进行赋值
    public void setUserDao(UserDao userDao) {
    
    
        this.userDao = userDao;
    }

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

    @Override
    public List<User> selectUser() {
    
    
        List<User> userList = userDao.selectUser();
        return userList;
    }
}

5.使用单元测试,测试是否成功

public class UserServiceTest {
    
    


//测试容器中的对象是否成功创建
    @Test
    public void testAccountMoney() {
    
    
       String config = "applicationContext.xml";
        ApplicationContext context =new ClassPathXmlApplicationContext(config);
        String[] beanDefinitionNames = context.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
    
    
            System.out.println("容器中的对象"+beanDefinitionName);
        }
    }
    
//测试添加操作
    @Test
    public void testUserServiceAdd() {
    
    
        String config = "applicationContext.xml";
        ApplicationContext context =new ClassPathXmlApplicationContext(config);
        UserService service = context.getBean("userService", UserService.class);
        int add = service.add(new User(null, "test", "123456"));
        //spring 和mybatis整合在一起的时候是默认自动提交事务的
        System.out.println(add);
    }

    @Test
    public void testUserServiceSelect() {
    
    
        String config = "applicationContext.xml";
        ApplicationContext context =new ClassPathXmlApplicationContext(config);
        UserService service = context.getBean("userService", UserService.class);
        List<User> userList = service.selectUser();
        for (User user : userList) {
    
    
            System.out.println(user);
        }

    }
}

6.测试结果

需要注意的是:
spring框架和mybatis框架进行整合的时候,事务是自动提交的,不需要在手动设置为手动提交事务.
ok,大功告成.按照步骤来肯定是没什么问题的,具体细节就不多说了.