项目管理与SSM框架（一）| Mybatis

什么是ORM框架？

ORM（Object Relationl Mapping），对象关系映射，即在数据库和对象之间作映射处理。
使用ORM框架代替JDBC后，框架可以帮助程序员自动进行转换，只要像平时一样操作对象，ORM框架就会根据映射完成对数据库的操作，极大的增强了开发效率。

什么是MyBatis?

MyBatis是一个半自动的ORM框架，其本质是对JDBC的封装。使用MyBatis不需要写JDBC代码，但需要程序员编写SQL语句。之前是apache的一个开源项目iBatis，2010年改名为MyBatis。

补充：
Hibernate也是一款持久层ORM框架，多年前的市场占有率很高，但近年来市场占有率越来越低。

MyBatis与Hibernate的比较：

• MyBatis是一个半自动的ORM框架，需要手写SQL语句。
• Hibernate是一个全自动的ORM框架，不需要手写SQL语句。
• 使用MyBatis的开发量要大于Hibernate。

为什么Hibernate市场占有率越来越低：

• 对于新手学习Hibernate时间成本比MyBatis大很多，MyBatis上手很快。
• Hibernate不需要写SQL语句是因为框架来生成SQL语句。对于复杂查询，开发者很难控制生成的SQL语句，这就导致SQL调优很难进行。
• 之前的项目功能简单，数据量小，所以使用Hibernate可以快速完成开发。而近年来项目的数据量越来越大，而互联网项目对查询速度要求也很高，这就要求我们一定要精细化的调整SQL语句。此时灵活性更强，手动编写SQL语句的MyBatis慢慢代替了Hibernate使用。
• 在高并发、大数据、高性能、高响应的互联网项目中，MyBatis是首选的持久框架。而对于对性能要求不高的比如内部管理系统等可以使用Hibernate。

MyBatis入门

环境搭建

1. 准备一个SQL文件导入数据库
2. 创建一个Maven工程

<dependencies>
    
    <dependency>
        <groupId>org.mybatisgroupId>
        <artifactId>mybatisartifactId>
        <version>3.5.7version>
    dependency>
    
    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>8.0.26version>
    dependency>
    
    <dependency>
    <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.10version>
    dependency>
    
    <dependency>
        <groupId>log4jgroupId>
        <artifactId>log4jartifactId>
        <version>1.2.12version>
    dependency>
    
    <dependency>
    	<groupId>com.alibabagroupId>
    	<artifactId>druidartifactId>
    	<version>1.1.21version>
    dependency>
dependencies>

3. 创建mybatis核心配置文件SqlMapConfig.xml

DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  
  <environments default="development">
    <environment id="development">
      
      <transactionManager type="JDBC" />
      
      <dataSource type="com.alibaba.druid.pool.DruidDataSource">
        
        <property name="url" value="jdbc:mysql://localhost:3306/db_name" />
        <property name="username" value="your_username" />
        <property name="password" value="your_password" />

        
        <property name="initialSize" value="5" />   
        <property name="maxActive" value="20" />    
       
      dataSource>
    environment>
  environments>

  
  <mappers>
    <mapper resource="mapper/YourMapper.xml" />
    
  mappers>
configuration>

4. 将log4j.properties文件放入resources中，让控制台打印SQL语句。
5. 创建实体类

public class User {
    private int id;
    private String username;
    private String sex;
    private String address;
 	// 省略getter/setter/构造方法/toString方法
}

创建持久层接口和映射文件

1. 在java目录创建持久层dao包接口

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

2. 在resource目录创建映射文件*Mapper.xml文件

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gb.mapper.UserMapper">
    <select id="findAll" resultType="com.gb.pojo.User">
       select * from user
    select>
mapper>

3. 将映射文件配置到mybatis核心配置文件中

<mappers>
    <mapper resource="/mapper/UserMapper.xml">mapper>
mappers>

resource后是你的创建的*.Mapper的文件的包路径，可以创建一个mapper包将映射文件都放到里面

• 映射文件要和接口名称相同。
• 映射文件要和接口的目录结构相同。（可以通过配置修改）
• 映射文件中namespace属性要写接口的全名。
• 映射文件中标签的id属性是接口方法的方法名。（必须一致）
• 映射文件中标签的resultType属性是接口方法的返回值类型。
• 映射文件中标签的parameterType属性是接口方法的参数类型。
• 映射文件中resultType、parameterType属性要写全类名，如果是集合类型，则写其泛型的全类名。（可以在配置文件中配置别名）
  paramterType 的参数对应的Java中类型的别名
  

测试持久层接口方法

在test包中创建测试类 通过@Before 和@After 标签

public class UserMapperTest {

	InputStream is = null;
    SqlSession session = null;
    UserMapper userMapper = null;
    
    @Before
    public void before() throws IOException {
        // （1）读取核心配置文件
        is = Resources.getResourceAsStream("SqlMapConfig.xml");
        // （2）创建SqlSessionFactoryBuilder对象
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // （3）SqlSessionFactoryBuilder对象获取SqlSessionFactory对象
        SqlSessionFactory factory = builder.build(is);
        // （4）SqlSessionFactory对象获取SqlSession对象
        session = factory.openSession();
        // （5）获取代理对象
        userMapper = session.getMapper(UserMapper.class);
    }

    @After
    public void after() throws IOException {
        // 释放资源
        session.close();
        is.close();
    }
    // 测试方法
    @Test
    public void findAll(){
    	// 代理对象执行方法
		List<User> all = userMapper.findAll();
    	all.forEach(System.out::println);
	}
}

MyBatis核心对象及工作流程

MyBatis核心对象

• SqlSessionFactoryBuilder
  SqlSession工厂构建者对象，使用构造者模式创建SqlSession工厂对象。
• SqlSessionFactory
  SqlSession工厂，使用工厂模式创建SqlSession对象。
• SqlSession
  该对象可以操作数据库，也可以使用动态代理模式创建持久层接口的代理对象操作数据库。
• Mapper
  持久层接口的代理对象，他具体实现了持久层接口，用来操作数据库。

MyBatis工作流程

1. 创建SqlSessionFactoryBuilder对象
2. SqlSessionFactoryBuilder对象构建了SqlSessionFactory对象：构造者模式
3. SqlSessionFactory对象生产了SqlSession对象：工厂模式
4. SqlSession对象创建了持久层接口的代理对象：动态代理模式
5. 代理对象操作数据库

Mapper动态代理原理

我们通过源码，了解MyBatis的Mapper对象究竟是怎么生成的，他又是如何代理接口的方法。

获取代理对象

点开测试类的 getMapper 方法，查看该方法最终调用了什么方法。

当看到 Proxy.newProxyInstance 时，可以确定 getMapper 方法最终调用的是JDK动态代理方法，且使用MapperProxy类定义代理方式

查看代理方式

点开MapperProxy类，查看invoke方法，查看代理对象是如何工作的。

可以看到，MapperProxy调用了MapperMethod的execute方法定义了代理方式，且底层调用的是SqlSession的方法，根据映射文件标签不同调用不同的SqlSession方法。

结论：

• SqlSession的getMapper方法，最终是调用的是JDK动态代理方法，生成一个代理对象，类型就是传入的接口类型。
• MapperProxy对象通过调用MapperMethod的execute方法定义了代理方式，该方法的底层调用的是SqlSession的方法。

MyBatis模糊查询

使用$定义参数

模糊查询如果不想在调用方法时参数加%，可以使用拼接参数的方式设置Sql：

<select id="findByUsernameLike" parameterType="string" resultType="com.itbaizhan.pojo.User">
   select * from user where username like '%${value}%'
select>

#和$的区别：

1. #表示sql模板的占位符，$表示将字符串拼接到sql模板中。
2. #可以防止sql注入，一般能用#就不用$。
3. ${}内部的参数名必须写value。

使用定义参数

如果使用 # 还不想在调用方法的参数中添加 % ，可以使用 ， 允许我们在 Sql语句以外创建一个变量，并可以将其绑定到当前的Sql语句中。用法如下：

<select id="findByUsernameLike" parameterType="string" resultType="com.itbaizhan.pojo.User">
   <bind name="likeName" value="'%'+username+'%'"/>
   select * from user where username like # {likeName}
select>

MyBatis分页查询

顺序传参

不推荐使用

/**
     * 分页查询
     * @param startIndex 开始索引
     * @param pageSize 每页条数
     * @return
     */
List<User> findPage(int startIndex,int pageSize);

POJO传参

自定义POJO类，该类的属性就是要传递的参数，在SQL语句中绑定参数时使用POJO的属性名作为参数名即可。此方式推荐使用。

public class PageQuery {
    private int startIndex;
    private int pageSize;
 // 省略getter/setter/构造方法
}

List<User> findPage2(PageQuery pageQuery);

Map传参

可以使用Map作为传递参数的载体，在SQL语句中绑定参数时使用Map的Key作为参数名即可。此方法推荐使用
1. 持久层接口方法

List<User> findPage3(Map<String,Object> params);

2. 映射文件

<select id="findPage3" resultType="com.itbaizhan.pojo.User" parameterType="map">
   select * from user limit # {startIndex},#{pageSize}
select>

3. 测试类

@Test
public void testFindPage3(){
    Map<String,Object> params = new HashMap();
    params.put("startIndex",0);
    params.put("pageSize",4);
    List<User> users = userMapper.findPage3(params);
    users.forEach(System.out::println);
}

MyBatis聚合查询、主键回填

主键回填

有时我们需要获取新插入数据的主键值。如果数据库中主键是自增的，这时我们就需要使用MyBatis的主键回填功能。
1. 持久层接口方法

void add(User user);

2. 映射文件

<insert id="add" parameterType="com.gb.user.User">
    
    <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
       SELECT LAST_INSERT_ID();
    selectKey>
   insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
insert>

SELECT LAST_INSERT_ID()：查询刚刚插入的记录的主键值，只适用于自增主键，且必须和insert语句一起执行。

3. 测试类

@Test
public void testAdd(){
    User user = new User("尚学堂", new Date(), "男", "北京");
    userMapper.add(user);
    session.commit();
    System.out.println(user.getId());
}

MyBatis配置文件_

properties

属性值定义。properties标签中可以定义属性值，也可以引入外部配置文件。无论是内部定义还是外部引入，都可以使用${name}获取值。
1. 编写db.properties

jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.username=root
jdbc.password=root
jdbc.initialSize=5
jdbc.maxActive=20

2. 在配置文件中引入db.properties

 <properties resource="db.properties">properties>
  
    <environments default="development">
        <environment id="development">
            
            <transactionManager type="JDBC">transactionManager>
            
            
            <dataSource type="com.alibaba.druid.pool.DruidDataSource">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
                <property name="initialSize" value="${jdbc.initialSize}"/> 
                <property name="maxActive" value="${jdbc.maxActive}"/>  
            dataSource>
        environment>
    environments>

MyBatis配置文件_

是配置MyBatis运行时的一些行为的，例如缓存、延迟加载、命名规则等一系列控制性参数。后期我们会使用该标签配置缓存和延迟加载等。

    <settings>
        
        
        
        <setting name="lazyLoadTriggerMethods" value=""/>
    settings>

MyBatis配置文件_

是配置MyBatis插件的。插件可以增强MyBatis功能，比如进行sql增强，打印日志，异常处理等。后期我们会使用该标签配置分页插件。

	<plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            
            <property name="helperDialect" value="mysql"/>
        plugin>
    plugins>

MyBatis配置文件_

MyBatis对常用类有默认别名支持，比如java.lang.Stirng的别名为string。除此之外，我们也可以使用 设置自定义别名。

    <typeAliases>
        
        <package name="com.gb.pojo"/>

        
        
    typeAliases>

MyBatis配置文件_

可以为MyBatis配置数据环境。

    <environments default="development">
        <environment id="development">
            
            <transactionManager type="JDBC">transactionManager>
            
            
            <dataSource type="com.alibaba.druid.pool.DruidDataSource">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
                <property name="initialSize" value="${jdbc.initialSize}"/> 
                <property name="maxActive" value="${jdbc.maxActive}"/>  
            dataSource>
        environment>
    environments>

dataSource的type属性：

• POOLED：使用连接池管理连接，使用MyBatis自带的连接池。
• UNPOOLED：不使用连接池，直接由JDBC连接。
• JNDI：由JAVAEE服务器管理连接，如果使用Tomcat作为服务器则使用Tomcat自带的连接池管理。

MyBatis配置文件_

用于注册映射文件或持久层接口，只有注册的映射文件才能使用，共有四种方式都可以完成注册：
1. 使用相对路径注册映射文件

<mappers>
  <mapper resource="/mapper/UserMapper.xml"/>
mappers>

这种方式比较好用
2. 使用绝对路径注册映射文件

<mappers>  
    <mapper url="file:///C:\Users\a\IdeaProjects\mybatiscase\mybatisDemo1\src\main\resources\com\gb\mapper\UserMapper.xml"/>
mappers>

3. 注册持久层接口

<mappers>  
    <mapper class="com.gb.mapper.UserMapper"/>
mappers>

4. 注册一个包下的所有持久层接口

<mappers>
    <package name="com.gb.mapper"/>
mappers>

MyBatis映射文件_

resultMap

标签的作用的自定义映射关系。
MyBatis可以将数据库结果集封装到对象中，是因为结果集的列名和对象属性名相同：
当POJO属性名和数据库列名不一致时，MyBatis无法自动完成映射关系。如：

此时有两种解决方案：
1. Sql语句的查询字段起与POJO属性相同的别名。

<select id="findAll" resultType="com.itbaizhan.pojo.Teacher">
   select tid as id,tname as teacherName from teacher;
select>

2 自定义映射关系
在映射文件中，使用 自定义映射关系：

<resultMap id="teacherMapper" type="com.itbaizhan.pojo.Teacher">
    
    <id property="id" column="tid">id>
    
    <result property="teacherName" column="tname">result>
resultMap>

在 标签中，使用resultMap属性代替 resultType 属性，使用自定义映射关系。

<select id="findAll" resultMap="teacherMapper">
   select * from teacher
select>

MyBatis映射文件_、

用来定义可重用的Sql片段，通过 引入该片段。如：Sql语句的查询字段起与POJO属性相同的别名，该Sql片段就可以重用。

<sql id="selectAllField">
   select tid as id,tname as teacherName
sql>
<select id="findAll" resultType="com.itbaizhan.pojo.Teacher">
    <include refid="selectAllField">include>
   from teacher;
select>

MyBatis映射文件_特殊字符处理

在Mybatis映射文件中尽量不要使用一些特殊字符，如： < ， > 等。
我们可以使用符号的实体来表示：

<select id="findById2" resultType="com.itbaizhan.pojo.Teacher">
   <include refid="selectAllField">include>
   from teacher where tid > #{id}
select>

动态SQL

标签内的Sql片段在满足条件后才会添加，用法为： 。

例如：根据不同条件查询用户：
1. 持久层接口添加方法

// 用户通用查询
List<User> findByCondition(User user);

2. 映射文件添加标签

<select id="findByCondition" parameterType="com.gb.pojo.User" resultType="com.gb.pojo.User">
   select * from user where 1 = 1
    <if test="username != null and username.length() != 0">
       and username like #{username}
    if>
    <if test="sex != null and sex.length()!= 0">
       and sex = #{sex}
    if>
    <if test="address != null and address.length() != 0">
       and address = #{address}
    if>
select>

3. 编写测试方法

@Test
public void testFindByCondition(){
    User user = new User();
    List<User> users1 =userMapper2.findByCondition(user); // 空的会查询所有
    users1.forEach(System.out::println);
    user.setUsername("%北京%");
    List<User> users2 = userMapper2.findByCondition(user); // 根据姓名模糊查询
    users2.forEach(System.out::println);
    user.setAddress("北京");
     List<User> users3 = userMapper2.findByCondition(user); // 姓名和地址组合多条件查询
    users3.forEach(System.out::println);
}

1. if中的条件不能使用&&/||，而应该使用and/or
2. if中的条件可以直接通过属性名获取参数POJO的属性值，并且该值可以调用方法。
3. where后为什么要加1=1？
   任意条件都可能拼接到Sql中。如果有多个条件，从第二个
   条件开始前都需要加And关键字。加上1=1这个永久成立的
   条件，就不需要考虑后面的条件哪个是第一个条件，后面的
   条件前都加And关键字即可。

可以代替sql中的where 1=1 和第一个and，更符合程序员的开发习惯，使用 后的映射文件如下：

<select id="findByCondition" resultType="User"parameterType="User">
   select * from user
    <where>
        <if test="username != null and username.length() != 0">
           username like #{username}
        if>
        <if test="sex != null and sex.length() != 0">
           and sex = #{sex}
        if>
    where>
select>

标签用在update语句中。借助 ，可以只对有具体值的字段进行更新。 会自动添加set关键字，并去掉最后一个if语句中多余的逗号。

    <update id="updateUser" parameterType="User">
        update user
        <set>
            <if test="username!=null and username.length !=0">
                username = #{username},
            if>
            <if test="sex !=null and sex.length !=0">
                sex = #{sex},
            if>
            <if test="address!=null and address.length !=0">
                address = #{address}
            if>
        set>
        <where>
            id = #{id}
        where>
    update>

、、

这些标签表示多条件分支，类似JAVA中的 switch…case 。 类似switch ， 类似 case ， 类似 default ，用法如下：

    <select id="selectUserByUsername" resultType="User" parameterType="string">
        <include refid="selectAllFiled">include>
        from user
        <where>
            <choose>
                <when test="username !=null and username.length() <5">
                    <bind name="likename" value="'%'+username+'%'"/>
                    username like #{likename}
                when>
                <when test="username !=null and username.length() <10">
                    username = #{username}
                when>
                <otherwise>
                    id =1
                otherwise>
            choose>
        where>
    select>

这段代码的含义为：用户名<5时使用模糊查询，用户名>=5并且<10时使用精确查询，否则查询id为1的用户

类似JAVA中的for循环，可以遍历集合或数组。 有如下属性：

• collection：遍历的对象类型
• open：开始的sql语句
• close：结束的sql语句
• separator：遍历每项间的分隔符
• item：表示本次遍历获取的元素，遍历List、Set、数组时表示每项元素，遍历map时表示键值对的值。
• index：遍历List、数组时表示遍历的索引，遍历map时表示键值对的键。

遍历数组

我们使用 遍历数组进行批量删除。
1. 持久层接口添加方法

void deleteBatch(int[] ids);

2. 映射文件添加标签

    <delete id="deleteBatch" parameterType="int">
        delete from user
        <where>
            <foreach open="id in (" close=")" separator="," collection="array" item="id">
                #{id}
            foreach>
        where>
    delete>

遍历Collection

遍历List和Set的方法是一样的，我们使用 遍历List进行批量添加。
1. 持久层接口添加方法

void insertBatch(List<User> users);

2. 映射文件添加标签

    <insert id="insertBatch" parameterType="User">
        insert into user(username,sex,address) values
        <foreach collection="list" separator="," item="user">
            (#{user.username},#{user.sex},#{user.address})
        foreach>
    insert>

遍历Map

我们使用 遍历Map进行多条件查询。
1. 持久层接口添加方法

/**
 * 多条件查询
 * @param map 查询的条件键值对 键：属性名 值：属性值
 * @return
 */
List<User> selectUserByMap(@Param("queryMap") Map<String,Object> map);

2. 映射文件添加标签

    <select id="selectUserByMap" resultType="User" parameterType="map">
        <include refid="selectAllFiled">include>
        from user
        <where>
            <foreach collection="queryMap" separator="and" index="key" item="value">
                ${key} = #{value}
            foreach>
        where>
    select>

缓存介绍

缓存是内存当中一块存储数据的区域，目的是提高查询效率。MyBatis会将查询结果存储在缓存当中，当下次执行相同的SQL时不访问数据库，而是直接从缓存中获取结果，从而减少服务器的压力。

• 什么是缓存？

存在于内存中的一块数据。

• 缓存有什么作用？

减少程序和数据库的交互，提高查询效率，降低服务器和数据库的压力。

• 什么样的数据使用缓存？

经常查询但不常改变的，改变后对结果影响不大的数据。

• MyBatis缓存分为哪几类？

一级缓存和二级缓存

• 如何判断两次Sql是相同的？

1. 查询的Sql语句相同
2. 传递的参数值相同
3. 对结果集的要求相同
4. 预编译的模板Id相同

MyBatis一级缓存

• MyBatis一级缓存也叫本地缓存。SqlSession对象中包含一个Executor对象，Executor对象中包含一个PerpetualCache对
  象，在该对象存放一级缓存数据。
• 由于一级缓存是在SqlSession对象中，所以只有使用同一个SqlSession对象操作数据库时才能共享一级缓存。MyBatis的一级缓存是默认开启的，不需要任何的配置。

MyBatis清空一级缓存

进行以下操作可以清空MyBatis一级缓存：

1. SqlSession 调用 close() ：操作后SqlSession对象不可用，该对象的缓存数据也不可用。
2. SqlSession 调用 clearCache() / commit() ：操作会清空一级缓存数据。
3. SqlSession 调用增删改方法：操作会清空一级缓存数据，因为增删改后数据库发生改变，缓存数据将不准确。

MyBatis二级缓存

• MyBatis二级缓存也叫全局缓存。数据存放在SqlSessionFactory中，只要是同一个工厂对象创建的SqlSession，在进行查询时都能共享数据。一般在项目中只有一个SqlSessionFactory对象，所以二级缓存的数据是全项目共享的。
• MyBatis一级缓存存放的是对象，二级缓存存放的是对象的数据。所以要求二级缓存存放的POJO必须是可序列化的，也就是
  要实现Serializable接口。
• MyBatis二级缓存默认不开启，手动开启后数据先存放在一级缓存中，只有一级缓存数据清空后，数据才会存到二级缓存中。

SqlSession 调用 clearCache() 无法将数据存到二级缓存中。

开启二级缓存

1. POJO类实现Serializable接口。
2. 在MyBatis配置文件添加如下设置：

<settings>
    <setting name="cacheEnabled" value="true"/>
settings>

3. 在映射文件添加 标签，该映射文件下的所有方法都支持二级缓存。

如果查询到的集合中对象过多，二级缓存只能缓存1024个对象引用。可以通过 标签的size属性修改该数量。

<cache size="2048"/>

MyBatis关联查询

MyBatis的关联查询分为一对一关联查询和一对多关联查询。

例如有学生类和班级类：
一个学生对应一个班级，也就是学生类中有一个班级属性，这就是一对一关系。
一个班级对应多个学生，也就是班级类中有一个学生集合属性，这就是一对多关系。

数据库设计如下：

实体类：

public class Student {
    private Integer sid;
    private String name;
    private int age;
    private String sex;
    private Classes classes;
    // 省略getter/setter/toString
}

public class Classes {
    private int cid;
    private String className;
    private List<Student> studentList;
    // 省略getter/setter/toString
}

MyBatis一对一关联查询

查询学生时，将关联的一个班级对象查询出来，就是一对一关联查询。

创建持久层接口

public interface StudentMapper {
    List<Student> findAll();
}

创建映射文件

	<sql id="selectAllField">
        select sid, name, age, sex, classId, cid, class_name
    sql>
    <resultMap id="studentMapper" type="Student">
        
        <id property="sid" column="sid">id>
        
        <result property="name" column="name">result>
        <result property="age" column="age">result>
        <result property="sex" column="sex">result>
        
        <association property="classes" column="classId" javaType="Classes">
            
            <id property="id" column="cid">id>
            
            <result property="className" column="className">result>
        association>
    resultMap>
    
    <select id="selectAll" resultMap="studentMapper">
        <include refid="selectAllField">include>
        from student s left join classes c on s.classId = c.cid;
    select>

MyBatis一对多关联查询

查询班级时，将关联的学生集合查询出来，就是一对多关联查询。

创建持久层接口

public interface ClassesMapper {
    List<Classes> findAll();
}

创建映射文件

	<sql id="selectAllField">
        select c.cid,c.className,s.sid,s.name, s.age,s.sex,s.classId
    sql>

    <resultMap id="classesMapper" type="Classes">
        <id property="id" column="cid">id>
        <result property="className" column="className">result>
        
        <collection property="studentList" column="classId" ofType="Student">
            
            <id property="sid" column="sid">id>
            
            <result property="name" column="name">result>
            <result property="age" column="age">result>
            <result property="sex" column="sex">result>
        collection>
    resultMap>
    
    <select id="selectAll" resultMap="classesMapper">
        <include refid="selectAllField">include>
        from classes c
        left join student s on c.cid = s.classId
    select>

MyBatis多对多关联查询

MyBatis多对多关联查询本质就是两个一对多关联查询。

例如有老师类和班级类：
一个老师对应多个班级，也就是老师类中有一个班级集合属性。
一个班级对应多个老师，也就是班级类中有一个老师集合属性。

实体类设计如下：

public class Teacher {
    private Integer tid;
    private String tname;
    private List<Classes> classes;
    // 省略getter/setter/toString
}

public class Classes {
    private Integer cid;
    private String className;
    private List<Student> studentList;
    private List<Teacher> teacherList;
    // 省略getter/setter/toString
}

在数据库设计中，需要建立中间表，双方与中间表均为一对多关系。

查询老师时，将关联的班级集合查询出来。

创建持久层接口

public interface TeacherMapper {
    List<Teacher> findAll();
}

创建映射文件

	<sql id="selectAllField">
        select t.tid, t.tname,  c.cid, c.className
    sql>

    <resultMap id="teacherMapper" type="Teacher">
        <id property="id" column="tid">id>
        <result property="name" column="tname">result>

        
        <collection property="classesList" column="tid" ofType="Classes">
            <id property="id" column="cid">id>
            <result property="className" column="className">result>
        collection>
    resultMap>
    
    <select id="selectAll" resultMap="teacherMapper">
        <include refid="selectAllField">include>
        FROM
        teacher t
        LEFT JOIN classes_teacher ct ON t.tid = ct.tid
        LEFT JOIN classes c ON  ct.cid = c.cid;
    select>

如果想查询班级时，将关联的老师集合查询出来，只需要修改班级映射文件的Sql语句和 即可：

<sql id="selectAllField">
        select c.cid,c.className,s.sid,s.name, s.age,s.sex,s.classId,t.tid,t.tname
    sql>

    <resultMap id="classesMapper" type="Classes">
        <id property="id" column="cid">id>
        <result property="className" column="className">result>
        
        <collection property="studentList" column="classId" ofType="Student">
            
            <id property="sid" column="sid">id>
            
            <result property="name" column="name">result>
            <result property="age" column="age">result>
            <result property="sex" column="sex">result>
        collection>
        <collection property="teacherList" column="tid" ofType="Teacher">
            <id property="id" column="tid">id>
            <result property="name" column="tname">result>
        collection>
    resultMap>
    
    <select id="selectAll" resultMap="classesMapper">
        <include refid="selectAllField">include>
        from classes c
        left join student s on c.cid = s.classId
        LEFT JOIN classes_teacher ct ON c.cid = ct.cid
        LEFT JOIN teacher t on ct.tid =t.tid;
    select>

MyBatis分解式查询_一对多

在MyBatis多表查询中，使用连接查询时一个Sql语句就可以查询出所有的数据。如：

# 查询班级时关联查询出学生
select *
    from classes
    left join student
    on student.classId = classes.cid

也可以使用分解式查询，即将一个连接Sql语句分解为多条Sql语句，如：

# 查询班级时关联查询出学生
select * from classes;
select * from student where classId = 1;
select * from student where classId = 2; 

这种写法也叫N+1查询。

连接查询：

• 优点：降低查询次数，从而提高查询效率。
• 缺点：如果查询返回的结果集较多会消耗内存空间。

N+1查询：

• 优点：结果集分步获取，节省内存空间。
• 缺点：由于需要执行多次查询，相比连接查询效率低。

我们以查询班级时关联查询出学生为例，使用N+1查询：

创建每个查询语句的持久层方法

public interface ClassesMapper {
    // 查询所有班级
    List<Classes> findAll();
}
public interface StudentMapper {
    // 根据班级Id查询学生
    List<Student> findByClassId(int classId);
}

在映射文件中进行配置

<resultMap id="MyClassesMapper" type="com.gb.pojo.Classes">
    <id property="cid" column="cid">id>
    <result property="className" column="className">result>
    
    <collection property="studentList" ofType="com.gb.pojo.Student" 									select="com.gb.mapper2.StudentMapper2.findByClassId" column="cid">
    collection>
resultMap>
<select id="findAll" resultMap="MyClassesMapper">
   select * from classes
select>

MyBatis分解式查询_一对一

查询学生时关联查询出班级也可以使用分解式查询，首先将查询语句分开

select * from student;
select * from classes where cid = ?;

创建每个查询语句的持久层方法

public interface StudentMapper {
     // 查询所有学生
    List<Student> findAll();
}
public interface ClassesMapper {
    // 根据ID查询班级
    Classes findByCid(int cid);
}

在映射文件中进行配置

<select id="findAll"
resultType="com.itbaizhan.pojo.Student">
   select *
   from student
select>
<select id="findByCid"
resultType="com.itbaizhan.pojo.Classes"
parameterType="int">
   select * from classes where cid = ${cid}
select>

修改主表映射文件中的查询方法

<resultMap id="MyStudentMapper" type="Student">
    <id property="sid" column="sid">id>
 	<result property="name" column="name">result>
    <result property="age" column="age">result>
    <result property="sex" column="sex">result>
    <association property="classes" javaType="Classes"
                select="com.gb.mapper2.ClassesMapper2.findByCid" column="classId">
    association>
resultMap>

<select id="findAll" resultMap="MyStudentMapper">
   select * from student
select>

MyBatis延迟加载

分解式查询又分为两种加载方式：

• 立即加载：在查询主表时就执行所有的Sql语句。
• 延迟加载：又叫懒加载，首先执行主表的查询语句，使用从表数据时才触发从表的查询语句。
  延迟加载在获取关联数据时速度较慢，但可以节约资源，即用即取。

开启延迟加载

设置所有的N+1查询都为延迟加载：

<settings>
	<setting name="lazyLoadingEnabled" value="true"/>
settings>

设置某个方法为延迟加载：
在 、 中添加fetchType属性设置加载方式。
lazy：延迟加载；eager：立即加载。

由于打印对象时会调用对象的 toString 方法， toString 方法默认会触发延迟加载的查询，所以我们无法测试出延迟加载的效果。
我们在配置文件设置lazyLoadTriggerMethods属性，该属性指定对象的什么方法触发延迟加载，设置为空字符串即可。

一般情况下，一对多查询使用延迟加载，一对一查询使用立即加载。

MyBatis注解开发

MyBatis可以使用注解替代映射文件。映射文件的作用就是定义Sql语句，可以在持久层接口上使用@Select/@Delete/@Insert/@Update定义Sql语句，这样就不需要使用映射文件了。

MyBatis注解开发_增删改查

   
	@Select("select * from user where username like #{username}")
	List<User> findByUsernameLike(String username);

    /**
     * @SelectKey 主键回填
     * @param user
     */
    @SelectKey(keyProperty = "id",keyColumn = "id",resultType = int.class,before = false,statement = "SELECT LAST_INSERT_ID() ")
    @Insert("insert into user(user_name, sex, address) values (#{username}, #{sex}, #{address})")
    void insertUser(User user);

    @Update("update user set username=#{username},sex=#{sex},address=#{address} where id=#{id}")
    void updateUser(User user);

    @Delete("delete from user where id=#{id}")
    void deleteUser(int userid);

MyBatis注解开发_动态Sql

在MyBatis中有 @SelectProvider 、 @UpdateProvider 、@DeleteProvider 、@InsertProvider 注解。当使用这些注解时将不在注解中直接编写SQL，而是调用某个类的方法来生成SQL。

 	/**
     * 用户通用查询
     * @SelectProvider 使用注解时将不在注解中直接编写SQL，而是调用某个类的方法来生成SQL。
     * @param user
     */
    @ResultMap("userMapper")
    @SelectProvider(type = UserProvider.class,method = "selectByConditionSql")
    List<User> selectUserByCondition(User user);

public class UserProvider {
    public String selectByConditionSql(User user){
        StringBuffer sb = new StringBuffer("select id, user_name, sex, address from user where 1=1");
        if (user.getUsername()!=null && user.getUsername().length()>0){
            sb.append(" and user_name like #{username}");
        }
        if (user.getSex()!=null && user.getSex().length()>0){
            sb.append(" and sex = #{sex}");
        }
        if (user.getAddress()!=null && user.getAddress().length()>0){
            sb.append(" and address = #{address}");
        }
        return sb.toString();
    }
}

MyBatis注解开发_自定义映射关系

当POJO属性名与数据库列名不一致时，需要自定义实体类和结果集的映射关系，在MyBatis注解开发中，使用 @Results 定义并使用自定义映射，使用 @ResultMap 使用自定义映射，用法如下：

    @Results(id = "userMapper",value = {
            @Result(id = true,property = "id",column = "id"),
            @Result(property = "username",column = "user_name"),
            @Result(property = "sex",column = "sex"),
            @Result(property = "address",column = "address")
    })
    @Select("select id, user_name, sex, address from user")
    List<User> selectUser();

    @ResultMap("userMapper")
    @Select("select id,user_name,sex,address from user where id =#{id}")
    User selectUserById(int userid);

MyBatis注解开发_二级缓存

MyBatis默认开启一级缓存，接下来我们学习如何在注解开发时使用二级缓存：

1. POJO类实现Serializable接口。
2. 在MyBatis配置文件添加如下设置：

<settings>
    <setting name="cacheEnabled" value="true"/>
settings>

3. 在持久层接口上方加注解@CacheNamespace(blocking=true)，该接口的所有方法都支持二级缓存。

MyBatis注解开发_一对一关联查询

在MyBatis的注解开发中对于多表查询只支持分解查询，不支持连接查询。

    @Select("select sid, name, age, sex, classId from student")
    @Results(id = "studentMapper",value = {
            @Result(id = true,property = "sid",column = "sid"),
            @Result(property = "name",column = "name"),
            @Result(property = "age",column = "age"),
            @Result(property = "sex",column = "sex"),
            /**
             * property:属性名
             * column:调用从表方法时传入的参数列
             * one:表示该属性是一个对象
             * select：调用的从表方法
             * fetchType：加载方式
             */
            @Result(property = "classes",column = "classId",
                    one = @One(select = "com.gb.dao.ClassesMapper.selectClassesById", fetchType = FetchType.EAGER)
            )
    })
    /**
     * 查询所有学生和所在的班级 (一对一查询)
     */
    List<Student> selectAll();

MyBatis注解开发_一对多关联查询

	@Results(id = "classesMapper",value = {
            @Result(id = true,property = "id",column = "cid"),
            @Result(property = "className",column = "class_name"),
            @Result(property = "studentList",column = "cid",
                    many = @Many(select = "com.gb.dao.StudentMapper.selectAllStudentByClassId",fetchType = FetchType.LAZY))
    })
     /**
     * 查询班级和班级里面的所有学生 (一对多查询)
     * @return
     */
    @Select("select cid,class_name from classes")
    List<Classes> selectAll();

注解开发与映射文件开发的对比

MyBatis中更推荐使用映射文件开发，Spring、SpringBoot更推荐注解方式。具体使用要视项目情况而定。它们的优点对比如下：

映射文件：

• 代码与Sql语句是解耦的，修改时只需修改配置文件，无需修改源码。
• Sql语句集中，利于快速了解和维护项目。
• 级联查询支持连接查询和分解查询两种方式，注解开发只支持分解查询。

注解：

• 配置简单，开发效率高。
• 类型安全，在编译期即可进行校验，不用等到运行时才发现错误。

PageHelper分页插件

开发过程中如果要进行分页查询，需要传入页数和每页条数。返回页面数据，总条数，总页数，当前页面，每页条数等数据。此时使用PageHelper插件可以快速帮助我们获取这些数据。

PageHelper是一款非常好用的开源免费的Mybatis第三方分页插件。使用该插件时，只要传入分页参数，即可自动生成页面对象。
我们使用该插件分页查询所有用户：

1. 引入依赖

<dependency>
	<groupId>com.github.pagehelpergroupId>
    <artifactId>pagehelperartifactId>
    <version>5.3.0version>
dependency>

2. Mybatis配置文件中配置PageHelper插件

<plugins>
    <plugin interceptor="com.github.pagehelper.PageInterceptor">
        
        <property name="helperDialect" value="mysql"/>
    plugin>
plugins>

3. 使用PageHelper插件

	 /**
     * 分页插件测试
     */
    @Test
    public void testSelectPage(){
        // (1)查询前设置分页参数，参数一：页数，从1开始。参数二：每页条数
        PageHelper.startPage(2,2);
        // (2)正常查询
        List<User> userList = userMapper.selectUser();
        // (3)创建页面对象，创建时将查询结果传入构造方法
        PageInfo pageInfo = new PageInfo(userList);
        // (4)打印页面对象的属性
        System.out.println("结果集："+pageInfo.getList());
        System.out.println("总条数："+pageInfo.getTotal());
        System.out.println("总页数"+pageInfo.getPages());
        System.out.println("当前页"+pageInfo.getPageNum());
        System.out.println("每页条数"+pageInfo.getSize());
    }

你可能感兴趣的:(mybatis)

• insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
  前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
• MyBatis 详解 阿贾克斯的黎明 javamybatis
  目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
• mybatis 二级缓存失效_Mybatis 缓存原理及失效情况解析 weixin_39844942 mybatis二级缓存失效
  这篇文章主要介绍了Mybatis缓存原理及失效情况解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1、什么是缓存[Cache]存在内存中的临时数据。将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。2、为什么要使用缓存减少和数据库的交互次
• 详解mybatis的一二级缓存以及缓存失效原因 仰望天花板 缓存数据库mybatisjavamysql
  数据库的大部分场景下是从磁盘读取，如果数据从内存进行读取，速度较比磁盘要快得多。但因为内存的容量有限，所以一般只会把使用和查询较多的数据缓存起来，以便快速反应，其他使用率不太多的继续存放在磁盘。mybatis分为一级缓存和二级缓存1.一级缓存一级缓存存放在SqlSqeeion上，默认开启1.1pojo@DatapublicclassRole{privateLongid;privateStringr
• 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？ 这孩子叫逆 Mybatis笔记mybatis数据库
  在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
• MyBatis批量插入大量数据 小黑屋说YYDS MyBatisjava
  1.思路分析批量插入这个问题，我们用JDBC操作，其实就是两种思路吧：用一个for循环，把数据一条一条的插入（这种需要开启批处理）。生成一条插入sql，类似这种insertintouser(username,address)values(‘aa’,‘bb’),(‘cc’,‘dd’)…。到底哪种快呢？我们从两方面来考虑这个问题：插入SQL本身执行的效率。网络I/O。先说第一种方案，就是用for循环循
• MyBatis 查询数据库_mybatis查询某个库的所有表名(2) 2401_84181942 程序员mybatisoracletomcat
  标签说明：***``标签**：需要指定namespace属性，表示命名空间，值为mapper接口的全限定名，包括全包名.类名。***``查询标签**：是用来执行数据库的查询操作的：`id`：是和Interface（接口）中定义的方法名称一样的，表示对接口的具体实现方法。`resultType`：是返回的数据类型，也就是开头我们定义的实体类。####2.4.4添加Service服务层实现代码如下：@
• 5-【JavaWeb】JUnit 单元测试及JUL 日志系统 weixin_44329069 JavaWebjunit单元测试
  1.使用JUnit进行单元测试JUnit是Java中非常流行的单元测试框架，MyBatis与JUnit可以很好地结合，来测试持久层代码的正确性。1.1添加JUnit依赖在使用JUnit之前，需要在pom.xml中引入JUnit依赖。junitjunit4.13.2test1.2单元测试基本结构假设我们要测试UserMapper中的getUserById方法，测试代码如下：importorg.apa
• 【免费】springboot项目申报管理系统|毕业设计|Javaweb项目 计算机学姐来啦 springbootssmjavaspringboot课程设计后端毕设毕业设计java-ee
  收藏点赞不迷路关注作者有好处编号：springboot375springboot项目申报管理系统开发语言：Java数据库：MySQL技术：Spring+SpringMVC+MyBatis工具：IDEA/Ecilpse、Navicat、Maven1.万字文档展示(部分)2.系统图片展示第5章系统详细设计5.1管理员功能模块的实现5.1.1项目列表如图5.1显示的就是项目列表页面，此页面提供给管理员的
• MyBatis系统学习（一）——项目结构及其含义 OEC小胖胖 MyBatismybatis学习web后端
  1.MyBatis简介MyBatis是一款优秀的持久层框架，它通过SQL映射的方式实现Java对数据库操作的映射，既保留了SQL语句的灵活性，也简化了代码的编写。在一个MyBatis项目中，核心部分主要有：配置文件（mybatis-config.xml）映射文件（Mapper.xml）实体类（Entity/POJO）接口类（Mapper接口）MyBatis会话工厂（SqlSessionFactor
• MyBatis 如何将 Mapper 接口与其 XML 映射文件关联：深入原理与实现 OEC小胖胖 web后端mybatisxmljavaweb后端
  MyBatis如何将Mapper接口与其XML映射文件关联：深入原理与实现1.概述MyBatis是一个简单、灵活的持久层框架，它通过SQL语句将Java对象与数据库进行映射。MyBatis支持基于XML和注解的配置方式。在实际开发中，XML映射文件与Mapper接口的关联是MyBatis的核心功能之一。通过这种关联，开发者可以在Mapper接口中定义方法，并在XML文件中编写SQL语句，从而实现数
• Mybatis实现员工管理系统 wu1113_ mybatisjavamaven
  文章目录1.案例需求2.编程思路3.案例源码4.小结1.案例需求在上次做的父子模块的maven以及Ajax实现人工管理系统的基础上使用Mybatis实现员工管理系统的增删改查，具体运行效果如下：2.编程思路Mybatis框架的一般执行流程：创建MyBatis配置文件mybatis-config.xml在里面加载数据源、事务等，管理映射文件创建需要的映射文件mapper.xml，用于映射表中列和实体
• springboot+mybatisplus实现基本的增删改查以及分页查询。这里使用的是Restful风格包括简单描述Restful是什么 okchan666 springbootjava
  先实现springboot+mybatisplus的增删改查接口使用postman测试：第一步创建项目导入依赖：直接给大家了：4.0.0org.springframework.bootspring-boot-starter-parent2.6.6com.okchanspringboot_07_ssmp0.0.1-SNAPSHOT1.8org.springframework.bootspring-b
• MyBatis 方法重载的陷阱及解决方案 molashaonian mybatis方法重载异常方法名相同
  在使用MyBatis进行开发时，尤其是使用注解模式（如@Select、@Insert等）时，开发者常常会遇到这样一个问题：为什么我的方法重载不能正常工作？即使在Java中允许方法名相同但参数不同的重载，MyBatis在处理注解的SQL方法时却并不支持这种方式。这篇文章将深入探讨MyBatis的这个特性及如何规避相关的坑。问题背景在标准的Java开发中，方法重载是一种常见的设计模式。方法重载允许我们
• Spring Cloud+Spring Boot+Mybatis+Java版电子招标采购系统源码 及 功能清单 Xiaohong0716 mybatisjavaspringcloud
  一、立项管理1、招标立项申请功能点：招标类项目立项申请入口，用户可以保存为草稿，提交。2、非招标立项申请功能点：非招标立项申请入口、用户可以保存为草稿、提交。3、采购立项列表功能点：对草稿进行编辑，驳回的立项编辑，在途流程查看。二、项目管理1、采购计划管理功能点：采购计划新增、编辑、删除2、采购过程管理功能点：查询、维护基准价、组建评审小组、项目答疑澄清、文件费保证金审核、供应商报价维护、查看评审
• BindingException: Invalid bound statement (not found) 小卡车555 MyBatismybatisjavamysql
  Mybatis出现绑定异常问题的解决org.apache.ibatis.binding.BindingException:Invalidboundstatement(notfound)一般的原因是Mapperinterface和xml文件的定义对应不上，需要检查包名，namespace，函数名称等能否对应上，需要比较细致的对比，我经常就是写错了一两个字母搞的很长时间找不到错误按以下步骤一一执行：1
• 工程项目管理系统源码与Spring Cloud：实现高效系统管理与二次开发 微服务技术分享 springcloudjava工程项目管理系统源码
  随着企业规模的不断扩大和业务的快速发展，传统的工程项目管理方式已经无法满足现代企业的需求。为了提高工程管理效率、减轻劳动强度、提高信息处理速度和准确性，企业需要借助先进的数字化技术进行转型。本文将介绍一款采用SpringCloud+SpringBoot+Mybatis技术框架的工程项目管理系统，该系统涵盖了项目管理、合同管理、预警管理、竣工管理、质量管理等多个方面，通过数据字典、编码管理、用户管理
• [附源码]SSM计算机毕业设计游戏账号交易平台JAVA 计算机程序源码 java游戏mysql
  项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
• Mybatis Mysql 莫夏_b560
  1、查询失败或者结果异常andfwbdh=#{fwbdh}更换成andfwbdh=#{fwbdh}
• 33. MyBatis中的@Param注解如何使用？如何在Mapper接口中传递多个参数？ 这孩子叫逆 Mybatis笔记javamybatistomcat
  在MyBatis中，@Param注解用于将方法参数绑定到SQL语句中的命名参数。它主要用于在Mapper接口中传递多个参数，以便在SQL语句中更方便地引用这些参数。为什么使用@Param注解？在MyBatis中，当Mapper接口的方法只有一个参数时，MyBatis会默认将这个参数的名称绑定为#{parameter}，可以直接在SQL语句中引用它。如果方法有多个参数，MyBatis默认使用para
• Python+Django毕业设计校园易购二手交易平台（程序+LW+部署） Python、JAVA毕设程序源码 课程设计javamysql
  项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
• Springboot3 整合 Mybatis3 （前程似锦） mybatisjavaspringboot
  Springboot3整合MybatisSpringboot3整合MybatisSpringboot3整合Mybatis一、导入依赖二、编写配置文件三、定义模型entity实体类四、在启动类上添加注解，表示mapper接口所在位置五、定义mapper接口六、定义mapper.xml映射文件七、service层八、测试一、导入依赖mybatis的必要依赖注意：使用springboot3的话要使用my
• mybatis支持json，Spring boot配置 Knight_9
  mysql5.7版本以后支持原生json格式，基于Springboot进行配置说明。mybatis支持mysql的json格式mysql-connector，mysql的驱动版本要大于等于5.1.40，否则json字段查询会发生乱码。继承BaseTypeHandler自定义一个json类型处理器，放到一个handler包下，例：packagecom.c.config.handler;importc
• 【Java】Mybatis Druid连接池配置详细 beautiful_huang Java
  pom.xmlcom.alibabadruid1.0.18.propertiesspring.datasource.driver-class-name=com.mysql.jdbc.Driverspring.datasource.url=jdbc:mysql://localhost:3306/mybatis2?characterEncoding=utf-8&useSSL=truespring.da
• 关于com.baomidou:mybatis-plus-boot-starter:jar:unknown was not found解决办法 波斯CD mybatisjarjava
  原型com.baomidoumybatis-plus-boot-starter修改以后解决了com.baomidoumybatis-plus-boot-starter3.5.3.1
• MyBatis-Plus 3.5.5的代码生成器 实践【完整代码】 qq_43513957 mybatis
  MyBatis-Plus3.5.5的代码生成器实践【完整代码】1.表：要有一个version字段，乐观锁更新。配置拦截器的代码packagecom.example.demo.zmybatisplusGenerator.config;importcom.baomidou.mybatisplus.annotation.DbType;importcom.baomidou.mybatisplus.exte
• 深入解析 MyBatis：从理论到项目实例 OEC小胖胖 web后端mybatisjavaspringweb后端
  深入解析MyBatis：从理论到项目实例目录MyBatis概述MyBatis项目结构及作用核心概念详解分页功能的实现与深入剖析动态SQL缓存机制详解与Spring集成常见问题与深入分析完整项目示例总结1.MyBatis概述MyBatis是一个轻量级的持久层框架，使用SQL查询语句来访问数据库。它与Java对象建立映射关系，通过配置文件或注解来管理SQL语句，灵活性高且与数据库操作直接相关，适合需要
• MyBatis Plus 实战详解 Aries263 redis分布式数据库
  一、引言MyBatisPlus（简称MP）是MyBatis的增强工具，旨在简化开发、提高效率。它保留了MyBatis的强大功能，并在其基础上进行了扩展和优化，提供了强大的CRUD操作、配置选项、条件构造器等功能。本文将详细介绍MyBatisPlus的安装、配置、基本操作以及分页和条件查询的使用。二、安装与配置1.添加依赖首先，在Maven项目的pom.xml中添加MyBatisPlus的依赖。以下
• 在springboot中，利用xml配置mybatis的方法 猪猡猪猡猪 javamybatismybatisspringbootxmljavamysql
  前置步骤参考博客：SpringBoot配置Mybatis的两种方式（通过XML配置和通过YML配置文件配置）_Darreni的博客-CSDN博客但按照博客中的关键代码和步骤创建的项目无法启动启动报错：Description:FailedtoconfigureaDataSource:'url’attributeisnotspecif:Reason:Failedtodetermineasuitable
• MyBatis 学习笔记(4) 动态SQL 张云飞Vir
  1.背景本节讲mybatis应对动态SQL的场景。2.知识动态SQL是指“条件"不固定的SQL，对比于一般的SQL，动态SQL会有一个或者多个条件/参数。比如：场景：查询的时候，如果用户输入了姓名，就按姓名模糊查询；同时又输入了邮箱，就再增加一个条件按姓名+邮箱两个条件查询。传统的拼接SQL很费力，拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。借助功能强大的基于OGNL的
• html 周华华 html
  js 1，数组的排列 var arr=[1,4,234,43,52,]; for(var x=0;x<arr.length;x++){    for(var y=x-1;y<arr.length;y++){      if(arr[x]<arr[y]){     &
• 【Struts2 四】Struts2拦截器 bit1129 struts2拦截器
  Struts2框架是基于拦截器实现的，可以对某个Action进行拦截，然后某些逻辑处理，拦截器相当于AOP里面的环绕通知，即在Action方法的执行之前和之后根据需要添加相应的逻辑。事实上，即使struts.xml没有任何关于拦截器的配置，Struts2也会为我们添加一组默认的拦截器，最常见的是，请求参数自动绑定到Action对应的字段上。   Struts2中自定义拦截器的步骤是：
• make:cc 命令未找到解决方法 daizj linux命令未知make cc
  安装rz sz程序时，报下面错误：   [root@slave2 src]# make posix cc   -O -DPOSIX -DMD=2 rz.c -o rz make: cc：命令未找到 make: *** [posix] 错误 127   系统：centos 6.6 环境：虚拟机   错误原因：系统未安装gcc，这个是由于在安
• Oracle之Job应用 周凡杨 oracle job
  最近写服务，服务上线后，需要写一个定时执行的SQL脚本，清理并更新数据库表里的数据，应用到了Oracle 的 Job的相关知识。在此总结一下。   一：查看相关job信息    1、相关视图  dba_jobs  all_jobs  user_jobs  dba_jobs_running 包含正在运行
• 多线程机制 朱辉辉33 多线程
  转至http://blog.csdn.net/lj70024/archive/2010/04/06/5455790.aspx 程序、进程和线程： 程序是一段静态的代码，它是应用程序执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的单位，一个进程执行过程中可以产生多个线程，每个线程有自身的
• web报表工具FineReport使用中遇到的常见报错及解决办法（一） 老A不折腾 web报表finereportjava报表报表工具
  FineReport使用中遇到的常见报错及解决办法（一） 这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。   出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。   1、address pool is full： 含义：地址池满，连接数超过并发数上
• mysql rpm安装后没有my.cnf 林鹤霄 没有my.cnf
  Linux下用rpm包安装的MySQL是不会安装/etc/my.cnf文件的， 至于为什么没有这个文件而MySQL却也能正常启动和作用，在这儿有两个说法， 第一种说法，my.cnf只是MySQL启动时的一个参数文件，可以没有它，这时MySQL会用内置的默认参数启动， 第二种说法，MySQL在启动时自动使用/usr/share/mysql目录下的my-medium.cnf文件，这种说法仅限于r
• Kindle Fire HDX root并安装谷歌服务框架之后仍无法登陆谷歌账号的问题 aigo root
  原文：http://kindlefireforkid.com/how-to-setup-a-google-account-on-amazon-fire-tablet/   Step 4: Run ADB command from your PC   On the PC, you need install Amazon Fire ADB driver and instal
• javascript 中var提升的典型实例 alxw4616 JavaScript
  // 刚刚在书上看到的一个小问题,很有意思.大家一起思考下吧 myname = 'global'; var fn = function () { console.log(myname); // undefined var myname = 'local'; console.log(myname); // local }; fn() // 上述代码实际上等同于以下代码 m
• 定时器和获取时间的使用 百合不是茶 时间的转换定时器
  定时器:定时创建任务在游戏设计的时候用的比较多   Timer();定时器 TImerTask();Timer的子类  由 Timer 安排为一次执行或重复执行的任务。       定时器类Timer在java.util包中。使用时，先实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定
• JDK1.5 Queue bijian1013 javathreadjava多线程Queue
  JDK1.5 Queue LinkedList： LinkedList不是同步的。如果多个线程同时访问列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方
• http认证原理和https bijian1013 httphttps
  一.基础介绍         在URL前加https://前缀表明是用SSL加密的。 你的电脑与服务器之间收发的信息传输将更加安全。         Web服务器启用SSL需要获得一个服务器证书并将该证书与要使用SSL的服务器绑定。 http和https使用的是完全不同的连接方式，用的端口也不一样,前者是80，后
• 【Java范型五】范型继承 bit1129 java
  定义如下一个抽象的范型类，其中定义了两个范型参数，T1，T2   package com.tom.lang.generics; public abstract class SuperGenerics<T1, T2> { private T1 t1; private T2 t2; public abstract void doIt(T
• 【Nginx六】nginx.conf常用指令(Directive) bit1129 Directive
  1. worker_processes    8; 表示Nginx将启动8个工作者进程，通过ps -ef|grep nginx,会发现有8个Nginx Worker Process在运行   nobody 53879 118449 0 Apr22 ? 00:26:15 nginx: worker process
• lua 遍历Header头部 ronin47 lua header 遍历　
  local headers = ngx.req.get_headers()   ngx.say("headers begin", "<br/>")   ngx.say("Host : ", he
• java-32.通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小(两数组的差最小)。 bylijinnan java
  import java.util.Arrays; public class MinSumASumB { /** * Q32.有两个序列a,b，大小都为n,序列元素的值任意整数，无序. * * 要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。 * 例如: * int[] a = {100,99,98,1,2,3
• redis 开窍的石头 redis
  在redis的redis.conf配置文件中找到# requirepass foobared 把它替换成requirepass 12356789 后边的12356789就是你的密码 打开redis客户端输入config get requirepass 返回 redis 127.0.0.1:6379> config get requirepass 1) "require
• [JAVA图像与图形]现有的GPU架构支持JAVA语言吗？ comsci java语言
        无论是opengl还是cuda，都是建立在C语言体系架构基础上的，在未来，图像图形处理业务快速发展，相关领域市场不断扩大的情况下，我们JAVA语言系统怎么从这么庞大，且还在不断扩大的市场上分到一块蛋糕，是值得每个JAVAER认真思考和行动的事情       
• 安装ubuntu14.04登录后花屏了怎么办 cuiyadll ubuntu
  这个情况，一般属于显卡驱动问题。 可以先尝试安装显卡的官方闭源驱动。 按键盘三个键：CTRL + ALT  +  F1 进入终端，输入用户名和密码登录终端： 安装amd的显卡驱动 sudo  apt-get  install  fglrx 安装nvidia显卡驱动 sudo  ap
• SSL 与 数字证书 的基本概念和工作原理 darrenzhu 加密ssl证书密钥签名
  SSL 与 数字证书 的基本概念和工作原理 http://www.linuxde.net/2012/03/8301.html SSL握手协议的目的是或最终结果是让客户端和服务器拥有一个共同的密钥，握手协议本身是基于非对称加密机制的，之后就使用共同的密钥基于对称加密机制进行信息交换。 http://www.ibm.com/developerworks/cn/webspher
• Ubuntu设置ip的步骤 dcj3sjt126com ubuntu
  在单位的一台机器完全装了Ubuntu Server，但回家只能在XP上VM一个，装的时候网卡是DHCP的，用ifconfig查了一下ip是192.168.92.128,可以ping通。 转载不是错： Ubuntu命令行修改网络配置方法 /etc/network/interfaces打开后里面可设置DHCP或手动设置静态ip。前面auto eth0，让网卡开机自动挂载. 1. 以D
• php包管理工具推荐 dcj3sjt126com PHPComposer
  http://www.phpcomposer.com/   Composer是 PHP 用来管理依赖（dependency）关系的工具。你可以在自己的项目中声明所依赖的外部工具库（libraries），Composer 会帮你安装这些依赖的库文件。 中文文档  入门指南  下载  安装包列表 Composer 中国镜像
• Gson使用四（TypeAdapter） eksliang jsongsonGson自定义转换器gsonTypeAdapter
  转载请出自出处：http://eksliang.iteye.com/blog/2175595 一.概述        Gson的TypeAapter可以理解成自定义序列化和返序列化 二、应用场景举例        例如我们通常去注册时（那些外国网站），会让我们输入firstName，lastName,但是转到我们都
• JQM控件之Navbar和Tabs gundumw100 htmlxmlcss
  在JQM中使用导航栏Navbar是简单的。 只需要将data-role="navbar"赋给div即可： <div data-role="navbar"> <ul> <li><a href="#" class="ui-btn-active&qu
• 利用归并排序算法对大文件进行排序 iwindyforest java归并排序大文件分治法Merge sort
    归并排序算法介绍，请参照Wikipeida zh.wikipedia.org/wiki/%E5%BD%92%E5%B9%B6%E6%8E%92%E5%BA%8F 基本思想： 大文件分割成行数相等的两个子文件，递归（归并排序）两个子文件，直到递归到分割成的子文件低于限制行数 低于限制行数的子文件直接排序 两个排序好的子文件归并到父文件 直到最后所有排序好的父文件归并到输入
• iOS UIWebView URL拦截 啸笑天 UIWebView
  本文译者：candeladiao，原文：URL filtering for UIWebView on the iPhone说明：译者在做app开发时，因为页面的javascript文件比较大导致加载速度很慢，所以想把javascript文件打包在app里，当UIWebView需要加载该脚本时就从app本地读取，但UIWebView并不支持加载本地资源。最后从下文中找到了解决方法，第一次翻译，难免有
• 索引的碎片整理SQL语句 macroli sql
  SET NOCOUNT ON DECLARE @tablename VARCHAR (128) DECLARE @execstr VARCHAR (255) DECLARE @objectid INT DECLARE @indexid INT DECLARE @frag DECIMAL DECLARE @maxfrag DECIMAL --设置最大允许的碎片数量,超过则对索引进行碎片
• Angularjs同步操作http请求with $promise qiaolevip 每天进步一点点学习永无止境AngularJS纵观千象
  // Define a factory app.factory('profilePromise', ['$q', 'AccountService', function($q, AccountService) { var deferred = $q.defer(); AccountService.getProfile().then(function(res) {
• hibernate联合查询问题 sxj19881213 sqlHibernateHQL联合查询
  最近在用hibernate做项目，遇到了联合查询的问题，以及联合查询中的N+1问题。 针对无外键关联的联合查询，我做了HQL和SQL的实验，希望能帮助到大家。（我使用的版本是hibernate3.3.2）   1 几个常识：  （1）hql中的几种join查询，只有在外键关联、并且作了相应配置时才能使用。  （2）hql的默认查询策略，在进行联合查询时，会产
• struts2.xml wuai struts
  <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache

按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他

首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.