MyBatis

MyBatis 是一款优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。将接口和 Java 的 POJOs(Plain Ordinary Java Objects,普通的 Java对象)映射成数据库中的表。

MyBatis是对JDBC的封装。相对于JDBC，MyBatis有以下优点：

• 优化获取和释放
  我们一般在访问数据库时都是通过数据库连接池来操作数据库，数据库连接池有好几种，比如C3P0、DBCP，也可能采用容器本身的JNDI数据库连接池。我们可以通过DataSource进行隔离解耦，我们统一从DataSource里面获取数据库连接，DataSource具体由DBCP实现还是由容器的JNDI实现都可以，所以我们将DataSource的具体实现通过让用户配置来应对变化。

• SQL统一管理，对数据库进行存取操作
  我们使用JDBC对数据库进行操作时，SQL查询语句分布在各个Java类中，这样可读性差，不利于维护，当我们修改Java类中的SQL语句时要重新进行编译。 Mybatis可以把SQL语句放在配置文件中统一进行管理，以后修改配置文件，也不需要重新就行编译部署。

• 生成动态SQL语句
  我们在查询中可能需要根据一些属性进行组合查询，比如我们进行商品查询，我们可以根据商品名称进行查询，也可以根据发货地进行查询，或者两者组合查询。如果使用JDBC进行查询，这样就需要写多条SQL语句。

• 能够对结果集进行映射
  我们在使用JDBC进行查询时，返回一个结果集ResultSet,我们要从结果集中取出结果封装为需要的类型 在Mybatis中我们可以设置将结果直接映射为自己需要的类型，比如：JavaBean对象、一个Map、一个List等等。

基本使用

• 引入mybatis、mysql依赖

<dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis</artifactId>
   <version>3.4.5</version>
</dependency>
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>8.0.32</version>
</dependency>

• 编写映射文件

在resources目录下创建文件com/sylone/mapper/UserMapper.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="userMapper">
    <select id="findAll" resultType="com.sylone.pojo.User">
        select * from user
    </select>
	
	<!--根据ID查询-->
	<select id="findById" parameterType="java.lang.Integer" 
						 resultType="com.sylone.pojo.UserInfo">
		select * from user_info where id=#{id}
	</select>
	
	<!--模糊查询-->
	<select id="findByName" parameterType="string" resultType="com.itmentu.pojo.UserInfo">
	    select * from user_info where username like CONCAT('%',#{name},'%')
	</select>
	
	<!--插入操作-->
	<insert id="add" parameterType="com.sylone.pojo.User">
		insert into user(id,username,password) values(#{id},#{username},#{password})
	</insert>
	
	<!--获取自增ID-->
	<insert id="addId" useGeneratedKeys="true" keyProperty="id" parameterType="User">
	    insert  into user(username,password) values(#{username},#{password})
	</insert>
	
	<!--删除操作-->
	<delete id="delete" parameterType="java.lang.Integer">
		delete from user where id=#{id}
	</delete>
	
	<!--更新操作-->
	<update id="update" parameterType="com.wang.pojo.User">
		update user set username=#{username},password=#{password} where id=#{id}
	</update>
</mapper>

• 配置mybatis核心配置文件

在resources目录下创建文件mybatis-config.xml（名称自定义）。并添加相应配置

<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///test"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <!-- 映射文件所在位置-->
        <mapper resource="com/sylone/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

• 测试

public static void main(String[] args) throws IOException {
	//加载核心配置文件
	InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
	//获得sqlSession工厂对象
	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
	//获得sqlSession对象，openSession(true)，自动提交事务
	SqlSession session = sqlSessionFactory.openSession();
	
	//查询list
	List<User> userList = session.selectList("userMapper.findAll");
	Iterator<User> iterator = userList.iterator();
	while(iterator.hasNext()){
		System.out.println(iterator.next());
	}
	
	//查询单个
	UserInfo userInfo = session.selectOne("userMapper.findById"，1);
    System.out.println(userInfo);
	
	//模糊查询
	UserInfo userInfo = session.selectOne("userMapper.findByName"，'张三');
	System.out.println(userInfo);
	
	//插入操作
	int insert = session.insert("userMapper.add",new User("Curry","30303030"));
	System.out.println(insert);
	
	//获取自增ID
	UserInfo user = new UserInfo(3, "zhaoliu", "32323");
	int addId = sqlSession.insert("userMapper.addId", user);
	Integer id = user.getId();
	System.out.println(id);
	
	//删除操作
	int delete = session.delete("userMapper.delete",1);
	System.out.println(delete);
	
	//更新操作
	int update = session.update("userMapper.update",new User(2,"科比","24-8")); 
	System.out.println(update);
	
	//涉及数据库数据变化，所以要使用sqlSession对象显示的提交事务，即sqlSession.commit()
	session.commit();
    //关闭sqlSession对象
	session.close();
}

配置文件

environments标签

主要是用来配置数据源环境，可以配置多个环境

事务管理类型有两种：

• JDBC：使用了JDBC 的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域
• MANAGED：这个配置几乎没做什么。不常用

数据源类型有三种：

• POOLED：这种数据源的实现利用“池”的概念将JDBC 连接对象组织起来
• UNPOOLED：这个数据源的实现只是每次被请求时打开和关闭连接
• JNDI：容器自带的数据源

mappers标签

用于加载映射文件，加载方式有如下几种

<!--使用相对于类路径资源（resources）的引用-->
<mapper resource="com/wang/mapper/UserMapper.xml"/>
<!--使用完全限定资源定位符（URL，磁盘上的位置）-->
<mapper url="file:///mapper/UserMapper.xml"/>
<!--使用映射器接口实现类的完全限定类名-->
<mapper class="com.wang.mapper.UserMapper"/>
<!--将包内的映射器接口实现全部注册为映射器-->
<package name="com.wang.mapper"/>

properties标签

用于加载额外配置的properties文件,例如将数据源的配置信息单独抽取成一个properties文件

<!--在classpath下面创建一个db.properties数据库连接配置文件-->
mysql.driverClassName=com.mysql.jdbc.Driver
mysql.url=jdbc:mysql://localhost:3306/gj1?characterEncoding=utf8
mysql.username=root
mysql.password=123456

<!--配置文件-->
<?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>
  <!-- properties标签 ：读取properties配置文件到mybatis框架中 -->
  <properties resource="db.properties"/>
  
  <environments default="dev_mysql">
    <environment id="dev_mysql">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
      	<!-- ${mysql.driverClassName} 属于OGNL语法，此处为${配置文件的key} -->
        <property name="driver" value="${mysql.driverClassName}"/>
        <property name="url" value="${mysql.url}"/>
        <property name="username" value="${mysql.username}"/>
        <property name="password" value="${mysql.password}"/>
      </dataSource>
    </environment>
  </environments>
  <!-- 配置映射文件 -->
  <mappers>
  	<mapper resource="com\mybatis\mapper\UserMapper.xml"/>
  </mappers>
</configuration>

MyBatis 在 3.4.2 版本之后加了一个默认值配置。首先，需要在 properties 标签中开启默认值配置

<?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>
  <properties resource="db.properties">
     <!--开启默认值配置-->
     <property name="org.apache.ibatis.parsing.PropertyParser.enable-default-value" 
	           value="true"/>
  </properties>
  
  <environments default="dev_mysql">
    <environment id="dev_mysql">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${mysql.driverClassName}"/>
        <property name="url" value="${mysql.url}"/>
		<!--设置默认值配置-->
        <property name="username" value="${mysql.username:root}"/>
        <property name="password" value="${mysql.password:root}"/>
      </dataSource>
    </environment>
  </environments>
  <!-- 配置映射文件 -->
  <mappers>
  	<mapper resource="com\mybatis\mapper\UserMapper.xml"/>
  </mappers>
</configuration>

typeAliases标签

MyBatis除了内置了常用类型的别名，自定义对象可以设置别名，每次直接用别名代替要转换的对象即可

<!--必须定义在setting或properties后面-->
<typeAliases>
    <typeAlias type="com.itmentu.pojo.UserInfo" alias="UserInfo" />
	<!--给com.itmentu.pojo包下的类都取个别名，类名默认是别名，也可通过@Alias("userInfo")指定-->
	<package name="com.itmentu.pojo"/>
</typeAliases>

typeHandlers标签

数据库类型和Java类型之间的转换器。MyBatis已经默认提供了一些常见的类型处理器，你可以重写类型处理器或创建你自己的类型处理器

开发步骤：

• 实现 org.apache.ibatis.type.TypeHandler接口，或继承一个类 org.apache.ibatis.type.BaseTypeHandler
• 覆盖4个未实现的方法

public class DateTypeHandler extends BaseTypeHandler<Date> {
    // 将 java 类型转换成数据库需要的类型
    public void setNonNullParameter(PreparedStatement preparedStatement, int i
	                               , Date date, JdbcType jdbcType) throws SQLException {
        long time = date.getTime();
        preparedStatement.setLong(i, time);
    }
    // 将数据库中的类型 转换成java类型
    // String 参数 要转换的字段的名称
    // ResultSet 查询出的结果集
    public Date getNullableResult(ResultSet resultSet, String s) throws SQLException {
        // 获得结果集中需要的数据(long) 转换成Date类型 返回
        long aLong = resultSet.getLong(s);
        Date date = new Date(aLong);
        return date;
    }
    // 将数据库中的类型 转换成java类型
    public Date getNullableResult(ResultSet resultSet, int i) throws SQLException {
        long aLong = resultSet.getLong(i);
        Date date = new Date(aLong);
        return date;
    }
    // 将数据库中的类型 转换成java类型
    public Date getNullableResult(CallableStatement callableStatement
	                            , int i) throws SQLException {
        long aLong = callableStatement.getLong(i);
        Date date = new Date(aLong);
        return date;
    }
}

• 在MyBatis核心配置文件中进行注册

<!--注册类型处理器-->
<typeHandlers>
    <typeHandler handler="com.lzjtu.handler.DateTypeHandler" />
</typeHandlers>

• 测试转换是否正确

@Test
public void test2() throws IOException {

     InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
     SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
	                                                         .build(resourceAsStream);
     SqlSession sqlSession = sqlSessionFactory.openSession();

     UserMapper mapper = sqlSession.getMapper(UserMapper.class);

     User user = mapper.findById(0);
     System.out.println("user中的birthday: " + user.getBirthday());
     sqlSession.close();
 }
 //数据库中以long型存储，Java数据展示中以时间格式展示

plugins标签

MyBatis可以使用第三方的插件来对功能进行扩展

分页助手 PageHelper 是将分页的复杂操作进行封装，使用简单的方式即可获得分页的相关数据

开发步骤：

• 导入通用 PageHelper 的坐标

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.1.10</version>
</dependency>

• 在 mybatis 核心配置文件中配置 PageHelper 插件

<?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>
  <plugins>
    <plugin interceptor="com.github.pagehelper.PageInterceptor">
      <!-- 该参数指明要连接的是哪个数据库 -->
      <property name="helperDialect" value="mysql"/>
      <!-- 支持通过Mapper接口参数来传递分页参数 -->
      <property name="supportMethodsArguments" value="true"/>
      <!-- 该参数默认为false -->
      <!-- 设置为true时，会将RowBounds第一个参数offset当成pageNum页码使用 -->
      <!-- 和startPage中的pageNum效果一样-->
      <property name="offsetAsPageNum" value="true"/>
      <!-- 该参数默认为false -->
      <!-- 设置为true时，使用RowBounds分页会进行count查询 -->
      <property name="rowBoundsWithCount" value="true"/>
      <!-- 设置为true时，如果pageSize=0或者RowBounds.limit = 0就会查询出全部的结果 -->
      <!-- （相当于没有执行分页查询，但是返回结果仍然是Page类型）-->
      <property name="pageSizeZero" value="true"/>
      <!-- 3.3.0版本可用 - 分页参数合理化，默认false禁用 -->
      <!-- 启用合理化时，如果pageNum<1会查询第一页，如果pageNum>pages会查询最后一页 -->
      <!-- 禁用合理化时，如果pageNum<1或pageNum>pages会返回空数据 -->
      <property name="reasonable" value="true"/>
      <!-- 3.5.0版本可用 - 为了支持startPage(Object params)方法 -->
      <!-- 增加了一个`params`参数来配置参数映射，用于从Map或ServletRequest中取值 -->
      <!-- 可配置pageNum,pageSize,count,pageSizeZero,reasonable,orderBy,不配置的用默认值 -->
      <!-- 不理解该含义的前提下，不要随便复制该配置 -->
      <property name="params" value="pageNum=start;pageSize=limit;"/>
      <!-- always总是返回PageInfo类型,check检查返回类型是否为PageInfo,none返回Page -->
      <property name="returnPageInfo" value="check"/>
    </plugin>
  </plugins>
</configuration>

• 测试分页数据获取

@Test
public void test3() throws IOException {

    InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
	                                                        .build(resourceAsStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    // 设置分页相关参数 当前页 + 每页显示的条数
    PageHelper.startPage(3, 3);

    List<User> all = mapper.findAll();
    for (User user: all){
        System.out.println(user);
    }

    // 获得与分页相关的参数
    PageInfo<User> pageInfo = new PageInfo<User>(all);
    System.out.println("当前页：" + pageInfo.getPageNum());
    System.out.println("每页显示条数：" + pageInfo.getPageSize());
    System.out.println("总条数：" + pageInfo.getTotal());
    System.out.println("总页数：" + pageInfo.getPages());
    System.out.println("上一页：" + pageInfo.getPrePage());
    System.out.println("下一页：" + pageInfo.getNextPage());
    System.out.println("是否是第一个：" + pageInfo.isIsFirstPage());
    System.out.println("是否是最后一个：" + pageInfo.isIsLastPage());

    sqlSession.close();
}

代理dao层

Mapper接口开发方法只需要程序员编写Mapper接口（相当于Dao接口），由Mybatis框架根据接口定义创建接口的动态代理对象，代理对象的方法体同Dao接口实现类方法一致

Mapper 接口开发需要遵循以下规范：

• Mapper.xml文件中的namespace与mapper接口的全限定名相同
• Mapper接口方法名和Mapper.xml中定义的每个statement的id相同
• Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql的parameterType的类型相同
• Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同

<?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.itheima.mapper.UserMapper">
    <select id="findAll" resultType="user">
        select * from user
    </select>
	<select id="findById" parameterType="int" resultType="user">
	    select * from user where id = #{id}
	</select>
</mapper>

public interface UserMapper{
	public List<User> findAll();
	public User findById(int id);
}
@Test
public void proxyTest() throws IOException {
	InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

	SqlSession sqlSession = sqlSessionFactory.openSession();
	
	//获得MyBatis框架生成的UserMapper接口的实现类
	UserMapper mapper = sqlSession.getMapper(UserMapper.class);
	
	List<User> userList = mapper.findAll();
	User user = mapper.findById(1);
}

多参数（@Param）

不需要使用arg0、arg1、param1、param2等等，直接使用@Param注解增强可读性

@Mapper
public interface StudentMapper{
    /**
     * 这是多参数查询
     * 根据name和sex查询Student信息
     * 如果是多个参数的话，MyBatis框架底层的做法如下：
     *     MyBatis框架会自动创建一个Map集合并且Map集合是以这种方式存储参数的
     *          map.put("arg0",name);/map.put("param1",name);
     *          map.put("arg1",sex);/map.put("param2",sex);
     *          
     * 使用Param注解指定Sql语句中的#{}命名
     * @param name
     * @param sex
     * @return
     */
    List<Student> selectByNameAndSex(
            @Param("nnn") String name,
            @Param("sss") Character sex);
}

<select id="selectByNameAndSex" resultType="student">
   select id,name,age from student where name = #{nnn} and sex = #{sss}
</select>

注意

当传递的是普通参数时，需要使用 #{} 的方式，而当传递的是 SQL 命令或 SQL 关键字时，需要使用 ${} 来对 SQL 中的参数进行直接替换并执行

动态SQL

动态 SQL 是 MyBatis 的强大特性之一，可以通过根据不同条件拼接 SQL 语句

if的使用

<select id="findByIdUsername" parameterType="user" resultType="user">
  SELECT * FROM user
  <where>
    <if test="id != 0">
	    id=#{id}
	</if>
    <if test="username!=null">
	    AND username=#{username}
	</if>
  </where>
</select>

if 标签 test 等于判断

//当使用==的时候，需要test外层使用 ''单引号，里面的参数使用 ""双引号！
<if test='flag != null and flag == "3"'>

foreach的使用

当循环执行sql的拼接操作，可以使用 foreach。例如：SELECT * FROM USER WHERE id IN (1,2,3)

<!--list-->
<select id="findByIds" parameterType="list" resultType="user">
	select * from user
	<where>
		<foreach collection="list" open="id in(" close=")" item="id" separator=",">
			#{id}
		</foreach>
	</where>
</select>

<!--map-->
<select id="findByIds" parameterType="map">
   select * from user
   <where>
      <foreach item="id" collection="ids" open="id in (" close=")" separator=",">
	     #{id}
	  </foreach>
   </where>
</select>

<!--array-->
<select id="findByIds" parameterType="String">
   select * from user
   <where>
      <foreach item="id" collection="array" open="id in (" close=")" separator=",">
	     #{id}
	  </foreach>
   </where>
</select>

<!--批量插入-->
<insert id="batchSave" parameterType="java.util.List">
    insert into user_info(id,username,address,age) values
    <foreach collection="list" item="user" separator=",">
        (#{user.id},#{user.username},#{user.address},#{user.age})
    </foreach>
</insert>

include的使用

当Sql语句有许多重复的地方时，可以使用sql将其中可将重复的sql提取出来，使用时用include引用即可

<sql id="selectAll">select * from User</sql>

<select id="findById" parameterType="int" resultType="user">
	<include refid="selectAll"></include> 
	where id=#{id}
</select>

<select id="findByIds" parameterType="list" resultType="user">
	<include refid="selectAll"></include> 
	<where>
		<foreach collection="array" open="id in(" close=")" item="id" separator=",">
			#{id}
		</foreach>
	</where>
</select>

多表操作

一对一查询

对应的 sql 语句：select * from orders o,user u where o.uid=u.id

• 创建Order和User实体

//Order
public class Order {
	private int id;
	private Date ordertime;
	private double total;
	
	//当前订单属于哪个客户
	private User user;
}

//User
public class User {
	private int id;
	private String username;
	private String password;
	private Date birthday;
}

• 创建OrderMapper接口

public interface OrderMapper {
	List<Order> findAll();
}

• 配置映射文件OrderMapper.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.lzjtu.mapper.OrderMapper">

    <resultMap id="orderMap" type="order">
		<!-- 手动指定字段与实体属性的映射关系
			 column: 数据表的字段名称
			 property: 实体的属性名称
		-->
        <id column="oid" property="id"></id>
        <result column="ordertime" property="ordertime" />
        <result column="total" property="total" />
		<!--<result column="uid" property="user.id" />-->
		<!--<result column="username" property="user.username" />-->
		<!--<result column="password" property="user.password" />-->
		<!--<result column="birthday" property="user.birthday" />-->
        <!--
            property: 当前实体(order) 中的属性名称
            javaType: 当前实体(order) 中的属性类型(User)
         -->
        <association property="user" javaType="user">
            <id column="uid" property="id" />
            <result column="username" property="username" />
            <result column="password" property="password" />
			<result column="birthday" property="birthday" />
        </association>
    </resultMap>
    
    <!--查询操作-->
    <select id="findAll" resultMap="orderMap">
        select *,o.id oid from user2 u,orders o where u.id=o.uid;
    </select>
</mapper>

• 核心配置文件

<?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>
    <!--通过properties标签加载外部properties文件-->
    <properties resource="jdbc.properties" />
    
    <typeAliases>
        <typeAlias type="com.lzjtu.domain.User" alias="user"></typeAlias>
        <typeAlias type="com.lzjtu.domain.Order" alias="order"></typeAlias>
        <typeAlias type="com.lzjtu.domain.Role" alias="role"></typeAlias>
    </typeAliases>
	<!--数据源环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
	<!--加载映射文件-->
    <mappers>
        <mapper resource="com/lzjtu/mapper/UserMapper.xml"></mapper>
        <mapper resource="com/lzjtu/mapper/OrderMapper.xml"></mapper>
    </mappers>
</configuration>

一对多查询

对应的sql语句：select *,o.id oid from user u left join orders o on u.id=o.uid

• 创建Order和User实体

//Order
public class Order {
	private int id;
	private Date ordertime;
	private double total;
}

//User
public class User {
	private int id;
	private String username;
	private String password;
	private Date birthday;
	
	//当前用户具备哪些订单
	private List<Order> orderList;
}

• 创建UserMapper接口

public interface UserMapper {
	List<User> findAll();
}

• 配置映射文件UserMapper.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.lzjtu.mapper.UserMapper">

    <resultMap id="userMap" type="user">
		<!-- 手动指定字段与实体属性的映射关系
			 column: 数据表的字段名称
			 property: 实体的属性名称
		-->
        <id column="id" property="id"></id>
		<result column="username" property="username" />
		<result column="password" property="password" />
		<result column="birthday" property="birthday" />
		<!--配置结合信息
		    property: 实体类中集合的名称
		    ofType: 当前集合中的数据类型
		 -->
		<collection property="orderList" ofType="order">
		        <!--封装order的数据-->
				<id column="oid" property="id" />
				<result column="ordertime" property="ordertime" />
				<result column="total" property="total" />
		</collection>
    </resultMap>
    
    <!--查询操作-->
    <select id="findAll" resultMap="orderMap">
        select *,o.id oid from user u left join orders o on u.id=o.uid;
    </select>
</mapper>

• 核心配置文件

<?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>
    <!--通过properties标签加载外部properties文件-->
    <properties resource="jdbc.properties" />
    
    <typeAliases>
        <typeAlias type="com.lzjtu.domain.User" alias="user"></typeAlias>
        <typeAlias type="com.lzjtu.domain.Order" alias="order"></typeAlias>
        <typeAlias type="com.lzjtu.domain.Role" alias="role"></typeAlias>
    </typeAliases>
	<!--数据源环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
	<!--加载映射文件-->
    <mappers>
        <mapper resource="com/lzjtu/mapper/UserMapper.xml"></mapper>
        <mapper resource="com/lzjtu/mapper/OrderMapper.xml"></mapper>
    </mappers>
</configuration>

多对多查询

需要引入中间表，对应的sql语句：
select u.,r.,r.id rid from user u left join user_role ur on u.id=ur.user_idinner join role r on ur.role_id=r.id

• 创建实体

//User
public class User {
	private int id;
	private String username;
	private String password;
	private Date birthday;
	
	//当前用户具备哪些角色
	private List<Role> roleList;
}

//Role
public class Role {
	private int id;
	private String rolename;
	private String roledesc;
}

• 创建UserMapper接口

public interface UserMapper {
	List<User> findAllRole();
}

• 配置映射文件UserMapper.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.lzjtu.mapper.UserMapper">

    <resultMap id="userRoleMap" type="user">
		<!-- 手动指定字段与实体属性的映射关系
			 column: 数据表的字段名称
			 property: 实体的属性名称
		-->
        <id column="id" property="id"></id>
		<result column="username" property="username" />
		<result column="password" property="password" />
		<result column="birthday" property="birthday" />
		<!--配置结合信息
		    property: 实体类中集合的名称
		    ofType: 当前集合中的数据类型
		 -->
		<collection property="roleList" ofType="role">
		        <!--封装order的数据-->
				<id column="rid" property="id" />
				<result column="rolename" property="rolename" />
				<result column="roledesc" property="roledesc" />
		</collection>
    </resultMap>
    
    <!--查询操作-->
    <select id="findAllRole" resultMap="userRoleMap">
        select u.*,r.*,r.id rid from user u left join user_role ur on u.id=ur.user_id 
		inner join role r on ur.role_id=r.id;
    </select>
</mapper>

• 核心配置文件

<?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>
    <!--通过properties标签加载外部properties文件-->
    <properties resource="jdbc.properties" />
    
    <typeAliases>
        <typeAlias type="com.lzjtu.domain.User" alias="user"></typeAlias>
        <typeAlias type="com.lzjtu.domain.Order" alias="order"></typeAlias>
        <typeAlias type="com.lzjtu.domain.Role" alias="role"></typeAlias>
    </typeAliases>
	<!--数据源环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
	<!--加载映射文件-->
    <mappers>
        <mapper resource="com/lzjtu/mapper/UserMapper.xml"></mapper>
        <mapper resource="com/lzjtu/mapper/OrderMapper.xml"></mapper>
    </mappers>
</configuration>

注解开发

常用注解

Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper映射文件了

@Insert //实现新增
@Update //实现更新
@Delete //实现删除
@Select //实现查询
@Result //实现结果集封装
@Results //可以与@Result 一起使用，封装多个结果集
@One //实现一对一结果集封装
@Many //实现一对多结果集封装

简单的增删改查

@Insert("insert into user2 values(#{id},#{username},#{password},#{birthday})")
public void save(User user);

@Select("select * from user2 where id=#{id}")
public User findById(int id);

@Select("select * from user2")
public List<User> findAll();

@Update("update user2 set usernme=${username}, password=#{password} where id=#{id}")
public void update(User user);

@Delete("delete from user2 where id=#{id}")
public void delete(int id);

修改MyBatis的核心配置文件

<mappers>
    <!--扫描使用注解的类所在的包-->
    <package name="com.itheima.mapper"></package>
</mappers>

复杂的映射开发

实现复杂关系映射之前我们可以在映射文件中通过配置 resultMap 来实现，使用注解开发后，我们可以使用@Results注解，@Result注解，@One注解，@Many注解组合完成复杂关系的配置

一对一查询

对应的sql语句：

select * from orders;
select * from user where id=查询出订单的uid;

• 创建Order和User实体

//Order
public class Order {
	private int id;
	private Date ordertime;
	private double total;
	
	//当前订单属于哪个客户
	private User user;
}

//User
public class User {
	private int id;
	private String username;
	private String password;
	private Date birthday;
}

• 创建OrderMapper接口

public interface OrderMapper {
	List<Order> findAll();
}

• 使用注解配置Mapper

//OrderMapper.java
@Select("select * from orders")
@Results({
        @Result(column = "id", property = "id"),
        @Result(column = "ordertime", property = "ordertime"),
        @Result(column = "total", property = "total"),
        @Result(
                property = "user", // 要封装的实体类中的属性名称
                column = "uid", // 根据那个字段取查询user表的数据
                javaType = User.class, // 要封装的实体类型
                // select属性 代表查询那个接口的方法获得数据
                one = @One(select = "com.lzjtu.mapper.UserMapper.findById")
        )
})
public List<Order> findAll();

//UserMapper.java
@Select("select * from user2 where id=#{id}")
public User findById(int id);

//另一种写法
@Select("select *,o.id oid from orders o, user2 u where o.uid=u.id")
@Results({
        @Result(column = "oid", property = "id"),
        @Result(column = "ordertime", property = "ordertime"),
        @Result(column = "total", property = "total"),
        @Result(column = "uid", property = "user.id"),
        @Result(column = "username", property = "user.username"),
        @Result(column = "password", property = "user.password")
})
public List<Order> findAll();

一对多查询

对应的sql语句：

select * from user;
select * from orders where uid=查询出用户的id;

• 创建Order和User实体

//Order
public class Order {
	private int id;
	private Date ordertime;
	private double total;
}

//User
public class User {
	private int id;
	private String username;
	private String password;
	private Date birthday;
	
	//当前用户具备哪些订单
	private List<Order> orderList;
}

• 创建UserMapper接口

public interface UserMapper {
	List<User> findAll();
}

• 使用注解配置Mapper

//UserMapper.java
@Select("select * from user2")
@Results({
        @Result(id=true, column = "id", property = "id"),
        @Result(column = "username", property = "username"),
        @Result(column = "password", property = "password"),
        @Result(
                property = "orderList",
                column = "id",
                javaType = List.class,
                many = @Many(select = "com.lzjtu.mapper.OrderMapper.findByUid")
        )

})
public List<User> findUserAndOrderAll();

//OrderMapper.java
@Select("select * from orders where id=#{uid}")
public List<Order> findByUid(int uid);

多对多查询

跟一对多写法差不多（除了查询语句），对应的sql语句：

select * from user;
select * from role r,user_role ur where r.id=ur.role_id and ur.user_id=用户的id

• 创建实体

//User
public class User {
	private int id;
	private String username;
	private String password;
	private Date birthday;
	
	//当前用户具备哪些角色
	private List<Role> roleList;
}

//Role
public class Role {
	private int id;
	private String rolename;
	private String roledesc;
}

• 创建UserMapper接口

public interface UserMapper {
	List<User> findAllRole();
}

• 使用注解配置Mapper

//UserMapper.java
@Select("select * from user")
@Results({
         @Result(id = true, column = "id", property = "id"),
         @Result(column = "username", property = "username"),
         @Result(column = "password", property = "password"),
         @Result(
                 property = "roleList",
                 column = "id",
                 javaType = List.class,
                 many = @Many(select = "com.lzjtu.mapper.RoleMapper.findByUid")
         )
 })
public List<User> findUserAndRoleAll();

//RoleMapper.java
@Select("select * from sys_user_role ur,sys_role r where ur.roleId=r.id and ur.userId=#{id}")
public List<Role> findByUid(int id);

ResultMap和ResultType的区别

resultType：数据库中的字段和pojo中的字段必须完全一致 resultMap：通常需要在mapper.xml中定义resultMap进行pojo和相应表字段的对应

spring整合mybatis（注解的方式）

导入Maven坐标

<dependencies>
  <!--spring相关-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.5.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.0.5.RELEASE</version>
  </dependency>
  
  <!--mybatis相关-->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.5</version>
  </dependency>
  <!--mybatis整合spring-->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.1</version>
  </dependency>
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.6</version>
  </dependency>
 <dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>druid</artifactId>
   <version>1.1.16</version>
 </dependency>
</dependencies>

• 业务逻辑层AccountService接口、AccountServiceImpl类

//AccountService接口
package com.itheima.service;

import com.itheima.domain.Account;
import java.util.List;
 
public interface AccountService {
 
    void save(Account account);
 
    void delete(Integer id);
 
    void update(Account account);
 
    List<Account> findAll();
 
    Account findById(Integer id);
 
}


//AccountServiceImpl类
package com.itheima.service.impl;
 
import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import com.itheima.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class AccountServiceImpl implements AccountService {
    // 自动装配 处理依赖关系 private AccountDao accountDao = new AccountDao();
    @Autowired 
    private AccountDao accountDao;
 
    public void save(Account account) {
        accountDao.save(account);
    }
 
    public void update(Account account){
        accountDao.update(account);
    }
 
    public void delete(Integer id) {
        accountDao.delete(id);
    }
 
    public Account findById(Integer id) {
        return accountDao.findById(id);
    }
 
    public List<Account> findAll() {
        return accountDao.findAll();
    }
}

• 数据操作层AccountDao

package com.itheima.dao;
 
import com.itheima.domain.Account;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import java.util.List;
 
public interface AccountDao {
 
    @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
    void save(Account account);
 
    @Delete("delete from tbl_account where id = #{id} ")
    void delete(Integer id);
 
    @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
    void update(Account account);
 
    @Select("select * from tbl_account")
    List<Account> findAll();
 
    @Select("select * from tbl_account where id = #{id} ")
    Account findById(Integer id);
}

• java代码代替spring的xml配置文件

package com.itheima.config;
 
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;
 
@Configuration  //相当于spring xml配置文件中的总体标签  <beans></beans>
@ComponentScan("com.itheima")   //扫描该包下是否有注解bean的类
@PropertySource({"jdbc.properties"})  //配置加载jdbc.properties文件 使用$符获取数据
@Import({JdbcConfig.class,MybatisConfig.class})  //导入2个配置
public class SpringConfig {
 
}

• 连接数据库的信息 jdbcConfig

package com.itheima.config;
 
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;
 
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
 
    @Bean
    public DataSource dataSource(){
 
        // 1、new 第三方bean/对象
        DruidDataSource dataSource =new DruidDataSource();
 
        // 2、给第三方bean/对象属性赋值
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
 
        // 3、把第三方bean/对象返回给该方法
        return dataSource;
    }
}

• spring整合mybatis的核心配置文件 MybatisConfig

package com.itheima.config;
 
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;

public class MybatisConfig {
   /*
    <properties resource="jdbc.properties"></properties> 
    <typeAliases>
	    <!-- 加载完sql映射文件后，是以该包下的POJO对象进行返回数据的 -->
        <package name="com.itheima.domain"/>    
    </typeAliases>
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"></property>
                <property name="url" value="${jdbc.url}"></property>
                <property name="username" value="${jdbc.username}"></property>
                <property name="password" value="${jdbc.password}"></property>
            </dataSource>
        </environment>
    </environments>
    */
 
    
    // 该方法new出来的SqlSessionFactoryBean对象相当于整合mybatis的核心配置文件中的上面那些信息
    @Bean
	// 传参的目的就是处理引用型依赖关系拿到DataSource对象
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){  
        // spring在使用getBean()调用获得该bean时，会自动调用该bean的getObject()方法
		// SqlSessionFactoryBean有getObject()方法
        SqlSessionFactoryBean sqfb =new SqlSessionFactoryBean();
        // 整合typeAliases
        sqfb.setTypeAliasesPackage("com.itheima.domain");
		// 整合jdbc连接信息
        sqfb.setDataSource(dataSource); 
		//添加分页支持
        Interceptor interceptor = new PageInterceptor();
        Properties properties = new Properties();
        properties.setProperty("helperDialect", "mysql");
        properties.setProperty("offsetAsPageNum", "true");
        properties.setProperty("rowBoundsWithCount", "true");
        properties.setProperty("reasonable", "true");
        properties.setProperty("supportMethodsArguments", "true");
        interceptor.setProperties(properties);
        sqfb.setPlugins(new Interceptor[]{interceptor});
		
        return sqfb;
    }
 
    /*
    <mappers>
        <!-- 加载sql映射文件 -->
        <package name="com.itheima.dao"></package>
    </mappers>
     */
	
	// 该方法new出来的MapperScannerConfigurer对象相当于整合mybatis的核心配置文件中的上面那些信息
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        // 1、new MapperScannerConfigurer对象
        MapperScannerConfigurer mp =new MapperScannerConfigurer();
        // 2、整合mybatis的核心配置信息
        mp.setBasePackage("com.itheima.dao");
        // 因为这里我们是用代理接口注解形式做的处理数据库的，也就是说没有用UserMapper.xml形式
        // 所以直接加载到dao层就行了，如果有xml核心配置文件的话，就加载到核心配置文件
        return mp;
    }
}

MyBatis Plus

基本介绍

MybatisPlus（简称MP）是在MyBatis基础上开发的增强型工具，旨在简化开发、提供效率。
我们虽然使用MP但是底层依然是MyBatis的东西，也就是说我们也可以在MP中写MyBatis的内容。
官方网站 (opens new window)

快速入门

• 创建数据库及表

create database if not exists mybatisplus_db character set utf8;
use mybatisplus_db;
CREATE TABLE user (
    id bigint(20) primary key auto_increment,
    name varchar(32) not null,
    password  varchar(32) not null,
    age int(3) not null ,
    tel varchar(32) not null
);

insert into user values(1,'Tom','tom',3,'18866668888');
insert into user values(2,'Jerry','jerry',4,'16688886666');
insert into user values(3,'Jock','123456',41,'18812345678');
insert into user values(4,'传智播客','itcast',15,'4006184000');

• 创建SpringBoot工程，勾选配置使用技术，只使用mysql，不用添加Mybatis，因为导入的MybatisPlus依赖，会根据依赖传递自动导入Mybatis、Mybatis-spring的依赖
• pom.xml添加MybatisPlus和druid依赖，由于MP并未被收录到idea的系统内置配置，无法直接选择加入，需要手动在pom.xml中配置添加

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.1</version>
</dependency>
<!--druid数据源可以加也可以不加，SpringBoot有内置的数据源，可以配置成使用Druid数据源-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>

• 添加相关配置信息

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    # UTC是标准时区，和咱们的时间差8小时，所以可以将其修改为Asia/Shanghai
    url: jdbc:mysql://localhost:3306/mybatisplus_db?serverTimezone=UTC 
    username: root
    password: root

• 根据数据库表创建实体类

//id类型不是int，而是bigint(20)，因为MybatisPlus默认使用雪花算法自增id，例 1561681377489510402L
public class User {   
    private Long id;    //注意id类型是Long
    private String name;
    private String password;
    private Integer age;
    private String tel;
    //setter...getter...toString方法略，别忘了自己生成
}


//注解了lombok的@Data会自动生成getter,setter,toString方法
@Data
//一般数据库表名tbl_user，这里注解@TableName("tbl_user")
@TableName("tbl_user")
public class User {
    //设置主键自增策略为auto，mp默认自增策略是ASSIGN_ID，雪花算法。也可以在yml中全局配置
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    //value属性起别名，select设置该字段是否参与查询，针对于一些密码等隐私数据不希望被查出来
    @TableField(value = "password",select = false)
    private String password;
    private Integer age;
 
    private String tel;
    //exist属性设置是否在数据库中存在该字段
    @TableField(exist = false)
    private String online;
    //乐观锁注解版本，需要搭配乐观拦截器
    @Version
    private Integer version;
    //逻辑删除，本质是更新，数据库内该字段默认是0，通过标记为1来判定删除。
    @TableLogic
    private Integer delete;
}

• 创建Dao接口，继承基础mapper：BaseMapper< User >

@Mapper
public interface UserDao extends BaseMapper<User>{
	
}

• Service层IService以及ServiceImpl（一般不使用）

//Service接口
public interface BaseProcedureService extends IService<BaseProcedure> {
	void testInsert()
}

//ServiceImpl类
@Service
public class BaseProcedureServiceImpl extends ServiceImpl<BaseProcedureMapper,BaseProcedure> implements BaseProcedureService {

    public void testInsert(){
        BaseProcedure result = this.getById("测试");
        System.out.println("result:{}"+result);
    }
}

• 编写引导类，Dao接口要想被容器扫描到，有两种解决方案
  • 在每个Dao接口上添加@Mapper注解，并且确保Dao处在引导类所在包或其子包中
  • 在引导类上添加@MapperScan注解，其属性为所要扫描的Dao所在包，该方案的好处是只需写一次

@SpringBootApplication
//@MapperScan("com.itheima.dao")
public class Mybatisplus01QuickstartApplication {
    public static void main(String[] args) {
        SpringApplication.run(Mybatisplus01QuickstartApplication.class, args);
    }
 
}

• 编写测试类

@SpringBootTest
class MpDemoApplicationTests {
 
	@Autowired
	private UserDao userDao;
	
	@Test
	public void testGetAll() {
		List<User> userList = userDao.selectList(null);
		System.out.println(userList);
	}
}

功能使用

五种主键自动生成策略

• AUTO策略：数据库默认自增策略
• NONE: 不设置id生成策略
• INPUT:用户手工输入id，如果id为null会报错
• ASSIGN_ID:雪花算法生成id(可兼容数值型与字符串型)，mp默认id策略
• ASSIGN_UUID:以UUID生成算法作为id生成策略

其他的几个策略均已过时，都将被ASSIGN_ID和ASSIGN_UUID代替掉

雪花算法

雪花算法(SnowFlake),是Twitter官方给出的算法实现 是用Scala写的。其生成的结果是一个64bit大小整数，它的结构如下图:

• 1bit,不用,因为二进制中最高位是符号位，1表示负数，0表示正数。生成的id一般都是用整数，所以最高位固定为0。
• 41bit-时间戳，用来记录时间戳，毫秒级
• 10bit-工作机器id，用来记录工作机器id,其中高位5bit是数据中心ID其取值范围0-31，低位5bit是工作节点ID其取值范围0-31，两个组合起来最多可以容纳1024个节点
• 序列号占用12bit，每个节点每毫秒0开始不断累加，最多可以累加到4095，一共可以产生4096个ID

标准CRUD使用

• 新增操作

@SpringBootTest
class Mybatisplus01QuickstartApplicationTests {
 
    @Autowired
    private UserDao userDao;
 
    @Test
    void testSave() {
        User user = new User();
        user.setName("黑马程序员");
        user.setPassword("itheima");
        user.setAge(12);
        user.setTel("4006184000");
        userDao.insert(user);
    }
}

• 删除操作

 @SpringBootTest
class Mybatisplus01QuickstartApplicationTests {
 
    @Autowired
    private UserDao userDao;
 
    @Test
    void testDelete() {
        //Long类型后面都有L字母，不加会溢出、报错，即使值为1也要加，即1L
        userDao.deleteById(1401856123725713409L);
		
		//根据map删除
		Map<String, Object> columnMap = new HashMap<>();
		columnMap.put("age",20);
		columnMap.put("name","张三");
		//将columnMap中的元素设置为删除的条件，多个之间为and关系
		int result = userDao.deleteByMap(columnMap);
		System.out.println("result = " + result);
    }
}

• 修改操作

@SpringBootTest
class Mybatisplus01QuickstartApplicationTests {
 
    @Autowired
    private UserDao userDao;
 
    @Test
    void testUpdate() {
        User user = new User();
        user.setId(1L);
        user.setName("Tom888");
        user.setPassword("tom888");
        userDao.updateById(user);
		
		User user = new User();
		user.setAge(22); //更新的字段
		//更新的条件
		QueryWrapper<User> wrapper = new QueryWrapper<>();
		wrapper.eq("id", 6);
		int result = this.userMapper.update(user, wrapper);
		System.out.println("result = " + result);
    }
}

• 根据ID查询

@SpringBootTest
class Mybatisplus01QuickstartApplicationTests {
 
    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetById() {
        User user = userDao.selectById(2L);
    }
}

• 查询所有

@SpringBootTest
class Mybatisplus01QuickstartApplicationTests {
 
    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll() {
        List<User> userList = userDao.selectList(null);
        System.out.println(userList);
    }
}

分页功能

IPage是一个接口，我们需要用它的实现类Page来构建它

使用了两种方法实现：

• 简单分页查询：用条件构造器QueryWrapper就能够实现
• 复杂分页查询：就必须自己手写mapper文件：联表查询

@RestController
public class UserController {

    @Autowired
    private UserService userService;
    
	 /**
     * <p>
     * 查询 : 根据gender性别查询用户列表，分页显示
     * </p>
     *
     * @param page 指定当前页码1 ，每页显示2行
     * @param state 状态
     * @return 分页对象
     */
    @RequestMapping("/{gender}")
    public void test(@PathVariable Integer gender) {
		// 模拟复杂分页查询
        IPage<UserEntity> userEntityIPage = userService.selectUserByGender(new Page<>(1, 2), gender);
        System.out.println("总页数： " + userEntityIPage.getPages());
        System.out.println("总记录数： " + userEntityIPage.getTotal());
        userEntityIPage.getRecords().forEach(System.out::println);
		// 简单分页查询
        QueryWrapper<UserEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("gender", gender);
        userService.pageByGender(new Page<>(1, 2), queryWrapper);
        System.out.println("总页数： " + userEntityIPage.getPages());
        System.out.println("总记录数： " + userEntityIPage.getTotal());
        userEntityIPage.getRecords().forEach(System.out::println);
    }
}


//UserService.java
@Service
public class UserService{

    @Autowired
    private UserMapper userMapper;

	// 模拟复杂分页查询
    public IPage<UserEntity> selectUserByGender(Page<UserEntity> page,Integer gender){
        return userMapper.selectUserByGender(page,gender);
    }
	
	// 简单分页查询:条件构造器QueryWrapper,不涉及到啥复杂的处理，直接调用DAO层
    public IPage<UserEntity> pageByGender(Page<UserEntity> page, QueryWrapper<UserEntity> queryWrapper){
        return userMapper.selectPage(page,queryWrapper);
    }
}

//UserMapper.java
@Mapper
public interface UserMapper extends BaseMapper<UserEntity> {

	// 通过性别分页查询
    IPage<UserEntity> selectUserByGender(Page<UserEntity> page, @Param("gender") Integer gender);
}

//UserMapper.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.hyl.demo.mapper.UserMapper">
    <sql id = "entity">
        a.id,a.username,a.password,a.gender,a.age,a.create_time
    </sql>
    <select id="selectUserByGender" resultType="com.hyl.demo.entity.UserEntity">
        select <include refid="entity"/> from user a
        <where>
            <if test="gender != null">
                and a.gender = #{gender}
            </if>
        </where>
    </select>
</mapper>

• 在config包下创建分页拦截器类

//注解为配置类@Configuration，也可以在引导类@Import({MybatisPlusConfig.class})
@Configuration
public class MybatisPlusConfig {
    //被Spring容器管理    
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        //1 创建mp拦截器对象MybatisPlusInterceptor
        MybatisPlusInterceptor mpInterceptor=new MybatisPlusInterceptor();
        //2 添加内置拦截器，参数为分页内置拦截器对象PaginationInnerInterceptor
        mpInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mpInterceptor;
    }
}

• 查看MybatisPlus标准日志

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #打印SQL日志到控制台

mybatis打印日志

mybatis:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #打印SQL日志到控制台

条件查询

Wrapper类就是用来构建查询条件的
包装器Wrapper是接口，实际开发中主要使用它的两个实现类：QueryWrapper和LambdaQueryWrapper

• 基本比较操作

eq：等于 =
ne：不等于 <>

alleq：全部eq(或个别isNull)
例子：allEq({id:1,name:"老王",age:null})--->id = 1 and name = '老王' and age is null 

gt：大于 >
ge：大于等于 >=

lt：小于 <
le：小于等于 <=

between：BETWEEN 值1 AND 值2
notBetween：NOT BETWEEN 值1 AND 值2

in：字段 IN (value.get(0), value.get(1), ...) 
notIn：字段 NOT IN (v0, v1, ...)

like()：前后加百分号,如 %J%
likeLeft()：左边加百分号,如 %J
likeRight()：后面加百分号,如 J%

• 查询包装器QueryWrapper

@SpringBootTest
class Mybatisplus02DqlApplicationTests {
 
    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        //创建QueryWrapper对象
        QueryWrapper qw = new QueryWrapper();
        //lt代表小于，大于是gt
        qw.lt("age",18);
        List<User> userList = userDao.selectList(qw);
        System.out.println(userList);
    }
}

• QueryWrapper的基础上使用lambda

@SpringBootTest
class Mybatisplus02DqlApplicationTests {
 
    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        //使用Lambda，QueryWrapper<User>必须加泛型
        QueryWrapper<User> qw = new QueryWrapper<User>();
        qw.lambda().lt(User::getAge, 10);//添加条件，使用Lambda不容易写错属性名
        List<User> userList = userDao.selectList(qw);
        System.out.println(userList);
    }
}

• LambdaQueryWrapper（推荐使用）

@SpringBootTest
class Mybatisplus02DqlApplicationTests {
 
    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
        lqw.lt(User::getAge, 10);
        List<User> userList = userDao.selectList(lqw);
        System.out.println(userList);
    }
}

• 多条件查询默认是and，or要用.or()

@SpringBootTest
class Mybatisplus02DqlApplicationTests {
 
    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
		//lqw.lt(User::getAge, 30);
		//lqw.gt(User::getAge, 10);
		//链式编程
        lqw.lt(User::getAge, 10).or().gt(User::getAge, 30);
        List<User> userList = userDao.selectList(lqw);
        System.out.println(userList);
    }
}

• 条件查询null值处理

在domain.query下新建一个模型类,让其继承User类，并在其中添加age2属性，UserQuery在拥有User属性后同时添加了age2属性。

@Data
public class User {
    private Long id;
    private String name;
    private String password;
    private Integer age;
    private String tel;
}
 
@Data
public class UserQuery extends User {
    private Integer age2;
}

//MP给我们提供了简化方式实现区间条件查询
@SpringBootTest
class Mybatisplus02DqlApplicationTests {
 
    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        //模拟页面传递过来的查询数据
        UserQuery uq = new UserQuery();
        uq.setAge(10);
        uq.setAge2(30);
        LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
        //第一个参数为判断条件
        lqw.lt(null!=uq.getAge2(),User::getAge, uq.getAge2());
        lqw.gt(null!=uq.getAge(),User::getAge, uq.getAge());
        List<User> userList = userDao.selectList(lqw);
        System.out.println(userList);
    }
}

查询指定字段

目前我们在查询数据的时候，什么都没有做默认就是查询表中所有字段的内容

//方法一（推荐）：使用Lambda
@SpringBootTest
class Mybatisplus02DqlApplicationTests {
 
    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
        lqw.select(User::getId,User::getName,User::getAge);
        List<User> userList = userDao.selectList(lqw);
        System.out.println(userList);
    }
}

//方法二（不建议）：不用lambda
@SpringBootTest
class Mybatisplus02DqlApplicationTests {
 
    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        QueryWrapper<User> lqw = new QueryWrapper<User>();
        lqw.select("id","name","age","tel");
        List<User> userList = userDao.selectList(lqw);
        System.out.println(userList);
    }
}

聚合查询

聚合查询不能用Lambda，只能用QueryWrapper

@SpringBootTest
class Mybatisplus02DqlApplicationTests {
 
    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        QueryWrapper<User> lqw = new QueryWrapper<User>();
        //lqw.select("count(*) as count");
        //SELECT count(*) as count FROM user
        //lqw.select("max(age) as maxAge");
        //SELECT max(age) as maxAge FROM user
        //lqw.select("min(age) as minAge");
        //SELECT min(age) as minAge FROM user
        //lqw.select("sum(age) as sumAge");
        //SELECT sum(age) as sumAge FROM user
        lqw.select("avg(age) as avgAge");
        //SELECT avg(age) as avgAge FROM user
        List<Map<String, Object>> userList = userDao.selectMaps(lqw);
        System.out.println(userList);
    }
}

分组查询

分组查询一定是要配合聚合函数的

@SpringBootTest
class Mybatisplus02DqlApplicationTests {
 
    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        QueryWrapper<User> lqw = new QueryWrapper<User>();
        lqw.select("count(*) as count,tel");
        lqw.groupBy("tel");
        List<Map<String, Object>> list = userDao.selectMaps(lqw);
        System.out.println(list);
    }
}

注意

MP只是对MyBatis的增强，如果MP实现不了，可以直接在DAO接口中使用MyBatis的方式实现

排序查询

@SpringBootTest
class Mybatisplus02DqlApplicationTests {
 
    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        LambdaQueryWrapper<User> lwq = new LambdaQueryWrapper<>();
        /**
         * condition：是否进行排序，当condition为true，进行排序，如果为false，则不排序
         * isAsc：是否为升序，true为升序，false为降序
         * columns：需要操作的列
         */
        lwq.orderBy(true,false, User::getId);
 
        userDao.selectList(lw
    }
}

多记录操作

@SpringBootTest
class Mybatisplus03DqlApplicationTests {
 
    @Autowired
    private UserDao userDao;
	
    @Test
    void testDelete(){
        //删除指定多条数据
        List<Long> list = new ArrayList<>();
        list.add(1402551342481838081L);
        list.add(1402553134049501186L);
        list.add(1402553619611430913L);
        userDao.deleteBatchIds(list);
		
		//查询指定多条数据
		List<Long> list = new ArrayList<>();
		list.add(1L);
		list.add(3L);
		list.add(4L);
		userDao.selectBatchIds(list);
    }
}

逻辑删除

逻辑删除底层其实是更新操作

• 修改数据库表添加deleted列
• 实体类添加属性
• 实体类设置逻辑删除成员
  • 单个实体类注解@TableLogic

  @Data
  //@TableName("tbl_user") 可以不写是因为配置了全局配置
  public class User {
      @TableId(type = IdType.ASSIGN_UUID)
      private String id;
      private String name;
      @TableField(value="pwd",select=false)
      private String password;
      private Integer age;
      private String tel;
      @TableField(exist=false)
      private Integer online;
      @TableLogic(value="0",delval="1")
      //value属性是默认值，delval是删除后修改的值
      private Integer deleted;
  }
  

  • yml全局配置

  mybatis-plus:
    global-config:
      db-config:
         逻辑删除字段名
        logic-delete-field: deleted
         逻辑删除字面值：未删除为0
        logic-not-delete-value: 0
         逻辑删除字面值：删除为1
        logic-delete-value: 1
  

注意

逻辑删除后的查询操作，只会查询where deleted=0的数据

乐观锁和悲观锁

• 乐观锁通过版本号控制事务的并发
• 悲观锁：就是锁定使用的资源，其他请求想要使用这个资源就必须排队，等这个资源释放了才能继续

这种方式是针对于小型企业的解决方案，因为数据库本身的性能就是个瓶颈，如果对其并发量超过2000以上的就需要考虑其他的解决方案了

乐观锁的实现方式：

• 数据库表添加列version，默认值1
• 在模型类中添加对应的属性，@Version

@Data
//@TableName("tbl_user") 可以不写是因为配置了全局配置
public class User {
    @TableId(type = IdType.ASSIGN_UUID)
    private String id;
    private String name;
    @TableField(value="pwd",select=false)
    private String password;
    private Integer age;
    private String tel;
    @TableField(exist=false)
    private Integer online;
    private Integer deleted;
    @Version
    private Integer version;
}

• 添加乐观锁的拦截器

@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor mpInterceptor() {
        //1.定义Mp拦截器
        MybatisPlusInterceptor mpInterceptor = new MybatisPlusInterceptor();
        //2.添加乐观锁拦截器
        mpInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
         //分页拦截器 
        //mpInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());   
        return mpInterceptor;
    }
}

• 先查询version再更新操作

要想实现乐观锁，首先第一步应该是拿到表中的version，然后拿version当条件在将version加1更新回到数据库表中，所以我们在修改的时候，需要对其进行查询

@SpringBootTest
class Mybatisplus03DqlApplicationTests {
 
    @Autowired
    private UserDao userDao;
	
    @Test
    void testUpdate(){
		
        //先通过要修改的数据id将当前数据查询出来
        User user1 = userDao.selectById(3L); //version=1
		User user2 = userDao.selectById(4L); //version=1
		
        user2.setName("Jock888");
        userDao.updateById(user2);           //version=2
		
        user1.setName("Jock666");
        userDao.updateById(user1);           //version=1修改失败
    }
}

多表连接查询

mybatis-plus作为mybatis的增强工具，它的出现极大的简化了开发中的数据库操作，但是长久以来，它的联表查询能力一直被大家所诟病。一旦遇到left join或right join的左右连接，你还是得老老实实的打开xml文件，手写上一大段的sql语句。

mybatis-plus-join (opens new window) 使用步骤：

• 在pom中添加 mybatis plus join依赖

<!-- mpj 依赖 -->
<dependency>
	<groupId>com.github.yulichang</groupId>
    <artifactId>mybatis-plus-join-boot-starter</artifactId>
    <version>1.4.5</version>
</dependency>
<!-- mp 依赖 -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.3.1</version>
</dependency>

• 添加两个数据库实体类 User 和 Address 和结果类 UserDTO

@Data
@ToString
@TableName("area")
public class User {
	@TableId
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

@Data
@ToString
@TableName("address")
public class Address {
	@TableId
    private Long id;
    private Long userId;
    private String city;
    private String address;
}

@Data
@ToString
public class UserDTO{
    private Long id;
    private String name;
    private Integer age;
    private String email;

	//address关联表中的两个字段
    private String city;
    private String address;
    
	//地址列表 用于接下来的一对多映射查询
	private List<Address> addressList;

	//地址 用于接下来的一对一映射查询
	private Address address;
}

• 添加mapper并且继承MPJBaseMapper

@Mapper
public interface UserMapper extends MPJBaseMapper<User> {

}

@Mapper
public interface AddressMapper extends MPJBaseMapper<Address> {

}

• 实体和mapper都建好了就可以直接用了

//一对多 selectCollection
@SpringBootTest
public class SampleTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelect() {
        MPJLambdaWrapper<User> wrapper = new MPJLambdaWrapper<User>()
                .selectAll(User.class)//查询user表全部字段
                .select(Address::getCity, Address::getAddress)
                .leftJoin(Address.class, Address::getUserId, User::getId);
        List<UserDTO> userList = userMapper.selectJoinList(UserDTO.class, wrapper);
        userList.forEach(System.out::println);
    }
}

//sql 打印
SELECT t.id,t.name,t.age,t.email,t2.city,t2.address 
FROM user t LEFT JOIN address t1 ON t1.user_id = t.id


//一对一 selectAssociation
@SpringBootTest
public class SampleTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelect() {
        MPJLambdaWrapper<User> wrapper = new MPJLambdaWrapper<User>()
                .selectAll(User.class)//查询user表全部字段
                .selectAssociation(Address::getCity, UserDTO::getAddress)
                .leftJoin(Address.class, Address::getUserId, User::getId);
        List<UserDTO> userList = userMapper.selectJoinList(UserDTO.class, wrapper);
    }
}

• 连表分页也是很常用的功能，MPJ也支持，调用selectJoinPage()就可以了

@SpringBootTest
public class SampleTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelect() {
        MPJLambdaWrapper<User> wrapper = new MPJLambdaWrapper<User>()
                .selectAll(User.class)//查询user表全部字段
                .select(Address::getCity, Address::getAddress)
                .leftJoin(Address.class, Address::getUserId, User::getId);
        Page<UserDTO> page= userMapper.selectJoinPage(new Page(1,10), UserDTO.class, wrapper);
    }
}

//sql打印
SELECT t.id,t.name,t.age,t.email,t2.city,t2.address 
FROM user t LEFT JOIN address t1 ON t1.user_id = t.id LIMIT ?

代码生成器

• 导入对应的jar包mybatis-plus,druid,lombok,代码生成器mybatis-plus-generator和模板引擎velocity-engine-core依赖

<?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 
		                     https://maven.apache.org/xsd/maven-4.0.0.xsd">
							 
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.1</version>
    </parent>
    <groupId>com.itheima</groupId>
    <artifactId>mybatisplus_04_generator</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--spring webmvc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 
        <!--mybatisplus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.1</version>
        </dependency>
 
        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>
 
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
 
        <!--test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
 
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
 
        <!--代码生成器-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.1</version>
        </dependency>
 
        <!--velocity模板引擎-->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.3</version>
        </dependency>
 
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
 
</project>
 

• 在引导类包下，创建代码生成类CodeGenerator

public class CodeGenerator {
    public static void main(String[] args) {
        //1.获取代码生成器的对象
        AutoGenerator autoGenerator = new AutoGenerator();
 
        //创建DataSourceConfig 对象设置数据库相关配置
        DataSourceConfig dataSource = new DataSourceConfig();
        dataSource.setDriverName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/mybatisplus_db?serverTimezone=UTC");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        autoGenerator.setDataSource(dataSource);
 
        //设置全局配置
        GlobalConfig globalConfig = new GlobalConfig();
		//设置代码生成位置
        globalConfig.setOutputDir(System.getProperty("user.dir")+"/plus/src/main/java");
        globalConfig.setOpen(false);    //设置生成完毕后是否打开生成代码所在的目录
        globalConfig.setAuthor("黑马程序员");    //设置作者
        globalConfig.setFileOverride(true);     //设置是否覆盖原始生成的文件
        globalConfig.setMapperName("%sDao");    //设置数据层接口名，%s为占位符，指代模块名称
        globalConfig.setIdType(IdType.ASSIGN_ID);   //设置Id生成策略
        autoGenerator.setGlobalConfig(globalConfig);
 
        //设置包名相关配置
        PackageConfig packageInfo = new PackageConfig();
        packageInfo.setParent("com.aaa");   //设置生成的包名
        packageInfo.setEntity("domain");    //设置实体类包名
        packageInfo.setMapper("dao");   //设置数据层包名
        autoGenerator.setPackageInfo(packageInfo);
 
        //策略设置
        StrategyConfig strategyConfig = new StrategyConfig();
        strategyConfig.setInclude("tbl_user");  //设置当前参与生成的表名，参数为可变参数
        strategyConfig.setTablePrefix("tbl_");  //设置数据库表的前缀名称
        strategyConfig.setRestControllerStyle(true);    //设置是否启用Rest风格
        strategyConfig.setVersionFieldName("version");  //设置乐观锁字段名
        strategyConfig.setLogicDeleteFieldName("deleted");  //设置逻辑删除字段名
        strategyConfig.setEntityLombokModel(true);  //设置是否启用lombok
        autoGenerator.setStrategy(strategyConfig);
        //2.执行代码生成器
        autoGenerator.execute();
    }
}

Spring Data

基本介绍

Spring Data用于简化数据库访问，支持NoSQL和关系数据存储。其主要目标是使用数据库的访问变得方便快捷

官网主页 (opens new window)

当然Spring Data还有很多封装好的工具可以供我们使用，主要的就是下面这四个：

• Spring Data JPA ：减少数据访问层的开发量
• Spring Data MongoDB：基于分布式数据层的数据库，在大数据层用的比较多
• Spring Data Redis：开源，支持网络、内存，而且可以持久化的，提供非常多的语言支持
• Spring Data Solr：高性能的基于Lucene的搜索功能，对查询性能优化，也有更好的扩展

Spring Data JPA

Spring Data JPA是 Spring 基于 ORM 框架、JPA（Java Persistence API） 规范的基础上封装的一套应用框架，底层使用了 Hibernate 的 JPA 技术实现，可使开发者用极简的代码即可实现对数据的访问和操作。

使用流程

• 要想在应用程序中使用Spring Data JPA，需要先引入依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

• 在使用Spring Data JPA时，需要在实体对象上添加符合JPA规范的注解

//表明是一个实体类
@Entity
//用于指定表名
@Table(name = "account")
public class Account implements Serializable {
    //用于标识主键
	@Id
	//用于标识自增数据的
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	private String accountNumber;
	private String accountName;
	
	//表示account表与authority表中数据的关联关系
	@ManyToMany(targetEntity = Authority.class)
	//JoinTable注解来指定account_authority中间表，
	//joinColumns和inverseJoinColumns分别指定中间表的字段名及account和authority两张主表的外键名
	@JoinTable(name = "account_authority", joinColumns =
		@JoinColumn(name = "account_id", referencedColumnName = "id"),inverseJoinColumns = 
		@JoinColumn(name = "authority_id",referencedColumnName = "id")
	)
	private List<Authority> authorities;
}

//JPA规范中提供了one-to-one、one-to-many、many-to-one、many-to-many这4种关系
//分别处理一对一、一对多、多对一以及多对多的关联场景

@Entity          //表明是一个实体类
@Table           //对应的数据表名
@Id              //主键
@GeneratedValue  //主键生成策略
@Column          //映射表对应的字段名
@Basic           //表示该属性是表字段的映射。 如果实体的字段上没有任何注解默认就是@Basic
@Transient       //表示该属性不是表字段的映射
@Lob             //将属性映射成支持的大对象类型 ，如Clob、Blob
@IdClass         //联合主键，一般不用也不推荐用
@Temporal        //用来设置Date类型的属性映射到对应精度的字段
@Enumerated      //直接映射枚举类型的字段

• 定义完实体对象后，再写Repository接口

@Repository
//一个继承了JpaRepository接口的空接口，实际上已经具备了访问数据库的基本CRUD功能
public interface AccountRepository extends JpaRepository<Account,Long>{
	
}

• 构建一个AccountService并直接注入AccountRepository接口

@Service
public class AccountService {
	@Autowired
	private AccountRepository accountRepository;
	
	public Account getAccountById(Long accountId) {
		return accountRepository.getOne(accountId);
	}
}

• 通过HTTP请求查询id为1的Account对象，可以获得如下数据

//除了account表中的账户基础数据之外，还同时获取了authority表中的用户权限数据
{
"id": 1,
"accountNumber": "Account1",
"accountName": "MyAccount",
"authorities": [
	{
	"id": 1,
	"authorityCode": " authorityCode1",
	"authorityName": " authorityName1",
	"description": "description1"
	},
	{
	"id": 2,
	"authorityCode": " authorityCode2",
	"authorityName": " authorityName2",
	"description": "description2"
	},
  ]
}

Reponsitory接口是Spring Data的核心接口

• Repository接口，是一个标记接口，不提供任何方法

public interface Repository<T, ID> {}

• 如果接口继承Repository接口，该接口就会被Spring所管理

//方式一
//使用 @RepositoryDefinition 注解，并为其指定 domainClass和idClass属性
@RepositoryDefinition(domainClass=Person.class,idClass=Integer.class)
public interface PersonRepsotory{}

//方式二
public interface AccountRepository extends Repository<Account,Long>

• Repository的子接口

CrudRepository //继承Repository，实现类CRUD相关的方法
PagingAndSortingRepository //继承CrudRepository接口，实现了分页排序的相关方法
JpaRepository //继承PagingAndSortingRepository接口，实现类JPA规范相关的方法

• CrudRepository接口的使用

@Reponsitory
public interface EmployeeCrudRepository extends CrudRepository<Employee, Integer> {}


@Service
public class EmployeeService {

    @Autowired
    private EmployeeRepository employeeRepository;

    @Autowired
    private EmployeeCrudRepository employeeCrudRepository;

    //根据id更新员工年龄
    @Transactional
    public void update(Integer id, Integer age) {
        employeeRepository.update(id, age);
    }

    //保存多条员工信息
    @Transactional
    public void save(List<Employee> employees) {
        employeeCrudRepository.saveAll(employees);
    }
}

• PagingAndSortingRepository接口的使用
  • 带排序的查询findAll（Sort sort）
  • 带排序的分页查询findAll（Pageable pageable）

@Reponsitory
public interface EmployeePagingAndSortingRepository 
                 extends PagingAndSortingRepository<Employee, Integer> {}
				 


public class EmployeePagingAndSortingRepositoryTest {
    @Test
    public void testPage() {
        Pageable pageable = PageRequest.of(1,4);
        Page<Employee> page = employeePagingAndSortingRepository.findAll(pageable);
        System.out.println("总页数" + page.getTotalElements());
        System.out.println("总记录数" + page.getTotalElements());
        System.out.println("当前是：" + page.getNumber()+1);
        System.out.println("当前页面的集合" + page.getContent());
        System.out.println("当前页面的记录时" + page.getNumberOfElements());
    }
}

使用@Query注解实现增删改查

可以通过自定义的 JPQL 完成select、update 和 delete 操作，注意: JPQL 不支持使用 insert

• Query注解的使用
• 实现DELETE和UPDATE操作时候必须加上@Modifying注解和事务
• Jpa继承的方法删除查找都是主键，非主键只有写原生sql语句
• 在service方法上添加事务操作@Transactional

public interface EmployeeRepository extends Repository<Employee, Integer> {
    //查询最大id员工
    @Query("select o from Employee o where id = (select max(id) from Employee t1)")
    Employee getEmployeeByMaxId();

    //根据姓名和年龄查询
    @Query("select o from Employee o where o.name = ?1 and o.age = ?2")
    List<Employee> queryParams1(String name, Integer age);

    //根据姓名和年龄查询
    @Query("select o from Employee o where o.name = :name and o.age = :age")
    List<Employee> queryParams2(@Param("name") String name, @Param("age") Integer age);

    //根据名字模糊查询
    @Query("select o from Employee o where o.name like %?1%")
    List<Employee> queryLike1(String name);

    //根据名字模糊查询
    @Query("select o from Employee o where o.name like %:name%")
    List<Employee> queryLike2(@Param("name") String name);

    //统计所有员工数量
	//使用原生Sql查询：nativeQuery = true
    @Query(nativeQuery = true, value = "select count(1) from employee")
    long getCount();

    //根据id更新员工年龄
    @Modifying
    @Query("update Employee o set o.age = :age where o.id = :id")
    void update(@Param("id") Integer id, @Param("age") Integer age);
	
	//使用原生Sql实现删除
	@Transactional
	@Modifying
	@Query(value="DELETE FROM b_classuser  WHERE uo_id = ?1",nativeQuery=true)
	void deleteClassByStudent(BigDecimal uoId);
}

事务的实现

@Service
public class EmployeeService {

    @Autowired
    private EmployeeRepository employeeRepository;

    //根据id更新员工年龄
    @Transactional
    public void update(Integer id, Integer age) {
        employeeRepository.update(id, age);
    }
}

使用方法名衍生查询

开发人员唯一要做的就是在JpaRepository接口中定义一个符合查询语义的方法

public interface EmployeeRepository extends Repository<Employee, Integer> {

    //通过名字查找雇员
    Employee findByName(String name);

    //查询名字以指定值开头且年龄小于指定值
    List<Employee> findByNameStartingWithAndAgeLessThan(String name, Integer age);

    //查询名字以指定值结束且年龄小于指定值
    List<Employee> findByNameEndingWithAndAgeLessThan(String name, Integer age);

    //查询名字在指定范围内或年龄小于指定值
    List<Employee> findByNameInOrAgeLessThan(List<String> names, Integer age);

    //查询名字在指定范围内且年龄小于指定值
    List<Employee> findByNameInAndAgeLessThan(List<String> names, Integer age);
}

查询条件不固定时，动态构建查询语句

可以通过继承JpaSpecification-Executor接口实现这类查询

@Repository
public interface AccountRepository extends JpaRepository<Account,Long>
                                         , JpaSpecificationExecutor<Account> {
}

对于JpaSpecificationExecutor接口而言，它背后就是Specification接口。我们可以简单理解该接口的作用就是构建查询条件。Specification接口的核心方法只有一个

public interface Specification<T> extends Serializable {
	//Root对象代表所查询的根对象，可以通过Root获取实体中的属性
	//CriteriaQuery对象代表一个顶层查询对象，用来实现自定义查询
	//CriteriaBuilder对象是用来构建查询条件的
	Predicate toPredicate(Root<T> root, CriteriaQuery<?> query,CriteriaBuilder cb);
}

基于Specification机制，我们根据AccountNumber查询订单的实现过程如下

public Account getAccountByAccountNumberBySpecification(String accountNumber) {
	Account account = new Account();
	account.setAccountNumber(accountNumber);
	
	Specification<Account> spec = new Specification<Account>() {
		@Override
		public Predicate toPredicate(Root<Account> root,CriteriaQuery<?> query, CriteriaBuilder cb) {
		  Path<Object> accountNumberPath = root.get("accountNumber");
		  Predicate predicate = cb.equal(accountNumberPath,accountNumber);
		  return predicate;
		}
	};
	return accountRepository.findOne(spec).orElse(new Account());
}