Mybatis-Spring

Mybatis

概述

什么是Mybatis，有什么特点

它是一款半自动的ORM持久层框架，具有较高的SQL灵活性，支持高级映射(一对一，一对多)，动态SQL，延迟加载和缓存等特性，但它的数据库无关性较低

什么是ORM

Object Relation Mapping，对象关系映射。对象指的是Java对象，关系指的是数据库中的关系模型，对象关系映射，指的就是在Java对象和数据库的关系模型之间建立一种对应关系

快速入门

1. 编写全局配置文件
2. 编写mapper映射文件
3. 加载全局配置文件，生成SqlSessionFactory
4. 创建SqlSession，调用mapper映射文件中的SQL语句来执行CRUD操作

开发实例

1.导入依赖的jar包

	<dependencies>
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>5.1.10version>
        dependency>
        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatisartifactId>
            <version>3.4.6version>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <version>1.18.12version>
            <scope>providedscope>
        dependency>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.10version>
            <scope>testscope>
        dependency>
    dependencies>

2.创建一个类

package com.yogurt.po;
 
import lombok.*;
 
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Student {
 
	private Integer id;
 
	private String name;
 
	private Integer score;
 
	private Integer age;
 
	private Integer gender;
 
}
 

3.编写映射文件

"1.0" encoding="UTF-8" ?>
mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 
<mapper namespace="test">
    <select id="findAll" resultType="com.yogurt.po.Student">
        SELECT * FROM student;
    select>
 
    <insert id="insert" parameterType="com.yogurt.po.Student">
        INSERT INTO student (name,score,age,gender) VALUES (#{name},#{score},#{age},#{gender});
    insert>
    
    <delete id="delete" parameterType="int">
        DELETE FROM student WHERE id = #{id};
    delete>
mapper>

4.编写数据源

db.url=jdbc:mysql://192.168.183.129:3306/yogurt?characterEncoding=utf8
db.user=root
db.password=root
db.driver=com.mysql.jdbc.Driver

5.全局配置文件

"1.0" encoding="UTF-8" ?>
configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    
    <properties resource="properties/db.properties">properties>
 
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                
                <property name="driver" value="${db.driver}"/>
                <property name="url" value="${db.url}"/>
                <property name="username" value="${db.user}"/>
                <property name="password" value="${db.password}"/>
            dataSource>
        environment>
    environments>
 
    <mappers>
        
        <mapper resource="StudentMapper.xml"/>
    mappers>
 
configuration>

6.编写业务

package com.yogurt.dao;
 
import com.yogurt.po.Student;
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 java.io.IOException;
import java.io.InputStream;
import java.util.List;
 
public class StudentDao {
 
	private SqlSessionFactory sqlSessionFactory;
 
	public StudentDao(String configPath) throws IOException {
		InputStream inputStream = Resources.getResourceAsStream(configPath);
		sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
	}
 
	public List findAll() {
		SqlSession sqlSession = sqlSessionFactory.openSession();
		List studentList = sqlSession.selectList("findAll");
		sqlSession.close();
		return studentList;
	}
 
	public int addStudent(Student student) {
		SqlSession sqlSession = sqlSessionFactory.openSession();
		int rowsAffected = sqlSession.insert("insert", student);
		sqlSession.commit();
		sqlSession.close();
		return rowsAffected;
	}
 
	public int deleteStudent(int id) {
		SqlSession sqlSession = sqlSessionFactory.openSession();
		int rowsAffected = sqlSession.delete("delete",id);
		sqlSession.commit();
		sqlSession.close();
		return rowsAffected;
	}
}
 

7.测试

public class SimpleTest {
 
	private StudentDao studentDao;
 
	@Before
	public void init() throws IOException {
		studentDao = new StudentDao("mybatis-config.xml");
	}
 
	@Test
	public void insertTest() {
		Student student = new Student();
		student.setName("yogurt");
		student.setAge(24);
		student.setGender(1);
		student.setScore(100);
		studentDao.addStudent(student);
	}
 
	@Test
	public void findAllTest() {
		List all = studentDao.findAll();
		all.forEach(System.out::println);
	}
}

总结：

1. 编写mapper.xml，书写SQL，并定义好SQL的输入参数，和输出参数
2. 编写全局配置文件，配置数据源，以及要加载的mapper.xml文件
3. 通过全局配置文件，创建SqlSessionFactory
4. 每次进行CRUD时，通过SqlSessionFactory创建一个SqlSession
5. 调用SqlSession上的selectOne，selectList，insert，delete，update等方法，传入mapper.xml中SQL标签的id，以及输入参数

在配置文件中各个子标签说明如下

• 一般将数据源的信息单独放在一个properties文件中,然后用这个标签引入,在下面environment标签中，就可以用${}占位符快速获取数据源的信息

• 用来开启或关闭mybatis的一些特性，比如可以用来开启延迟加载，可以用来开启二级缓存
   

• 在mapper.xml中需要使用parameterType和resultType属性来配置SQL语句的输入参数类型和输出参数类型，类必须要写上全限定名，比如一个SQL的返回值映射为Student类，则resultType属性要写com.yogurt.po.Student，这太长了，所以可以用别名来简化书写，比如

  <typeAliases>
      <typeAlias type="com.yogurt.po.Student" alias="student"/>
  typeAliases>
  

• 用来配置数据源

• 用来配置mapper.xml映射文件，这些xml文件里都是SQL语句

mapper.xml的SQL语句中的占位符${}和#{}

一般会采用#{}，#{}在mybatis中，最后会被解析为?，其实就是Jdbc的PreparedStatement中的?占位符，它有预编译的过程，会对输入参数进行类型解析(如果入参是String类型，设置参数时会自动加上引号)，可以防止SQL注入

而${}，一般会用在模糊查询的情景，比如SELECT * FROM student WHERE name like '%${name}%';

基于Mapper代理的示例

package com.yogurt.mapper;
 
import com.yogurt.po.Student;
 
import java.util.List;
 
public interface StudentMapper {
 
	List findAll();
 
	int insert(Student student);
 
	int delete(Integer id);
 
	List findByName(String value);
}

我们的mapper.xml文件如下

"1.0" encoding="UTF-8" ?>
mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 
<mapper namespace="com.yogurt.mapper.StudentMapper">
    <select id="findAll" resultType="com.yogurt.po.Student">
        SELECT * FROM student;
    select>
 
    <insert id="insert" parameterType="com.yogurt.po.Student">
        INSERT INTO student (name,score,age,gender) VALUES (#{name},#{score},#{age},#{gender});
    insert>
 
    <delete id="delete" parameterType="int">
        DELETE FROM student WHERE id = #{id};
    delete>
 
    <select id="findByName" parameterType="string" resultType="student">
        SELECT * FROM student WHERE name like '%${value}%';
    select>
mapper>

mapper接口和mapper.xml之间需要遵循一定规则，才能成功的让mybatis将mapper接口和mapper.xml绑定起来

1. mapper接口的全限定名，要和mapper.xml的namespace属性一致
2. mapper接口中的方法名要和mapper.xml中的SQL标签的id一致
3. mapper接口中的方法入参类型，要和mapper.xml中SQL语句的入参类型一致
4. mapper接口中的方法出参类型，要和mapper.xml中SQL语句的返回值类型一致
    

三种加载mapper的方式总结

加载普通的xml文件，传入xml的相对路径(相对于类路径)

使用mapper接口的全限定名来加载，若mapper接口采用注解方式，则不需要xml;若mapper接口没有采用注解方式，则mapper接口和xml文件的名称要相同，且在同一个目录

扫描指定包下的所有mapper，若mapper接口采用注解方式，则不需要xml;若mapper接口没有采用注解方式，则mapper接口和xml文件的名称要相同，且在同一目录

主键返回

通常我们会将数据库表的主键id设为自增。在插入一条记录时，我们不设置其主键id，而让数据库自动生成该条记录的主键id，那么在插入一条记录后，如何得到数据库自动生成的这条记录的主键id呢？

使用useGeneratedKeys和keyProperty属性

<insert id="insert" parameterType="com.yogurt.po.Student" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO student (name,score,age,gender) VALUES (#{name},#{score},#{age},#{gender});
    insert>

缓存

一级缓存

默认开启，同一个SqlSesion级别共享的缓存，在一个SqlSession的生命周期内，执行2次相同的SQL查询，则第二次SQL查询会直接取缓存的数据，而不走数据库，当然，若第一次和第二次相同的SQL查询之间，执行了DML(INSERT/UPDATE/DELETE)，则一级缓存会被清空，第二次查询相同SQL仍然会走数据库

一级缓存在下面情况会被清除

• 在同一个SqlSession下执行增删改操作时（不必提交），会清除一级缓存
• SqlSession提交或关闭时（关闭时会自动提交），会清除一级缓存
• 对mapper.xml中的某个CRUD标签，设置属性flushCache=true，这样会导致该MappedStatement的一级缓存，二级缓存都失效（一个CRUD标签在mybatis中会被封装成一个MappedStatement）
• 在全局配置文件中设置 ，这样会使一级缓存失效，二级缓存不受影响

二级缓存

默认关闭，可通过全局配置文件中的开启二级缓存总开关，然后在某个具体的mapper.xml中增加，即开启了该mapper.xml的二级缓存。二级缓存是mapper级别的缓存，粒度比一级缓存大，多个SqlSession可以共享同一个mapper的二级缓存。注意开启二级缓存后，SqlSession需要提交，查询的数据才会被刷新到二级缓存当中

Spring

概述

什么是Spring

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。

IOC本质

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。