Mybatis学习

Mybatis入门

搭建环境

1. 创建maven工程

    Groupid:com.xuexi
    ArtifactId:mybatis01
    Packing:jar

2. 添加坐标

    
        org.mybatis
        mybatis
        3.4.5
    
    
        junit
        junit
        4.10
        test
    
    
        mysql
        mysql-connector-java
        5.1.6
        runtime
    
    
        log4j
        log4j
        1.2.12
    

3. 编写User实体类

4. 编写持久层接口IUserDao

    public interface IUserDao {
        /**
         * 查询所有用户
         * @return
         */
        List findAll();
    }

5. 编写resources中持久层接口的映射文件IUserDao.xml

   要求：

   • 创建位置：必须和持久层接口在相同的包中

   • 名称：必须以持久层接口名称命名文件夹，扩展名是.xml

       
       
       
           
           
               select * from user
           
       

6. 编写SqlMapConfig.xml配置文件

7. 编写测试类

    public class MybatisTest {
        public static void main(String[] args)throws Exception {
            //1.读取配置文件
            InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.创建 SqlSessionFactory 的构建者对象
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //3.使用构建者创建工厂对象 SqlSessionFactory
            SqlSessionFactory factory = builder.build(in);
            //4.使用 SqlSessionFactory 生产 SqlSession 对象
            SqlSession session = factory.openSession();
            //5.使用 SqlSession 创建 dao 接口的代理对象
            IUserDao userDao = session.getMapper(IUserDao.class);
            //6.使用代理对象执行查询所有方法
            List users = userDao.findAll();
            for(User user : users) {
            System.out.println(user);
            }
            //7.释放资源
            session.close();
            in.close();
        }
    }

基于注解的mybatis使用

1. 在持久层接口中添加注解

    public interface IUserDao {
        /**
         * 查询所有用户
         * @return
         */
        @Select("select * from user")
        List findAll();
    }

2. 修改SqlMapConfig.xml

3. 注意事项

   在使用基于注解的Mybatis配置时，请移除xml的映射配置（IUserDao.xml）

基于代理Dao实现CRUD操作

使用要求：

1. 持久层接口和持久层接口的映射配置必须在相同的包下

2. 持久层映射配置中 mapper 标签的 namespace 属性取值必须是持久层接口的全限定类名

3. SQL 语句的配置标签,,,的 id 属性必须和持久层接口的方法名相同

   根据ID查询

   1. 在持久层接口中添加findById方法

       User findById(Integer userId);

   2. 在用户的映射配置文件中配置

   select * from user where id = #{uid}

   说明：

   1. resultType属性：用于指定结果集的类型
   2. parameterType属性：用于指定传入参数的类型
   3. sql语句中使用 #{} 字符：代表占位符，相当于原来jdbc部分的 ? ，都是用于执行语句时替换实际的数据。具体的数据是由 #{} 里面的内容决定的
   4. #{}中内容的写法：由于数据类型是基本类型，所以此处可以随意写

4. 在测试类添加测试

    public class MybastisCRUDTest {
        private InputStream in ;
        private SqlSessionFactory factory;
        private SqlSession session;
        private IUserDao userDao;
   
        @Test
        public void testFindOne() {
            //6.执行操作
            User user = userDao.findById(41);
            System.out.println(user);
        }
   
        @Before//在测试方法执行之前执行
        public void init()throws Exception {
            //1.读取配置文件
            in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.创建构建者对象
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //3.创建 SqlSession 工厂对象
            factory = builder.build(in);
            //4.创建 SqlSession 对象
            session = factory.openSession();
            //5.创建 Dao 的代理对象
            userDao = session.getMapper(IUserDao.class);
        }
   
        @After//在测试方法执行完成之后执行
        public void destroy() throws Exception{
            session.commit();
            //7.释放资源
            session.close();
            in.close();
        }
    }

保存操作

1. 在持久层接口中添加新增方法

    int saveUser(User user);

2. 在用户的映射配置文件中配置

    
    
        insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
    

   说明：

   1. parameterType属性：代表参数的类型，因为我们要传入的是一个类的对象，所以类型就写类的全名称
   2. sql语句中使用 #{} 字符：代表占位符，相当于原来jdbc部分的 ? ，都是用于执行语句时替换实际的数据。具体的数据是由 #{} 里面的内容决定的
   3. #{} 中内容的写法：由于保存方法的参数是一个 User 对象，此处要写 User 对象中的属性名称。使用的是 ognl 表达式
   4. ognl 表达式：它是apache提供的一种表达式语言，全称是：Object Graphic Navigation Language 对象图导航语言。按照一定的语法格式来获取数据的，语法格式就是使用 #{对象.对象} 的方式。 #{user.username} 它会先去找 user 对象，然后在 user 对象中找到 username 属性，并调用 getUsername() 方法把值取出来。但是我们在 parameterType 属性上指定了实体类名称，所以可以省略 user. 而直接写 username。

3. 添加测试方法

    @Test
    public void testSave(){
        User user = new User();
        user.setUsername("modify User property");
        user.setAddress("北京市顺义区");
        user.setSex("男");
        user.setBirthday(new Date());
        System.out.println("保存操作之前： "+user);
        //5.执行保存方法
        userDao.saveUser(user);
        System.out.println("保存操作之后： "+user);
    }

   打开 Mysql 数据库发现并没有添加任何记录，原因是什么？
   这一点和 jdbc 是一样的，我们在实现增删改时一定要去控制事务的提交，那么在 mybatis 中如何控制事务
   提交呢？
   可以使用: session.commit(); 来实现事务提交。 加入事务提交后的代码如下：

    @After//在测试方法执行完成之后执行
    public void destroy() throws Exception{
        session.commit();
        //7.释放资源
        session.close();
        in.close();
    }

4. 扩展：新增用户id的返回值

   新增用户后，同时还要返回当前新增用户的id值，因为id是由数据库的自动增长来实现的，所以就相当于我们要在新增后将自动增长 auto_increment 的值返回

    
        
        
            select last_insert_id();
        
        insert into user(username,birthday,sex,address)
        values(#{username},#{birthday},#{sex},#{address})
    

用户更新

1. 在持久层接口中添加更新方法

    int updateUser(User user);

2. 在用户的映射配置文件中配置

    
    
        update user set username=#{username},birthday=#{birthday},sex=#{sex}, address=#{address} where id=#{id}
    

3. 添加测试方法

    @Test
    public void testUpdateUser()throws Exception{
        //1.根据 id 查询
        User user = userDao.findById(52);
        //2.更新操作
        user.setAddress("北京市顺义区");
        int res = userDao.updateUser(user);
        System.out.println(res);
    }

用户删除

1. 在持久层接口中添加删除方法

    int deleteUser(Integer userId);

2. 在用户的映射配置文件中配置

    
    
        delete from user where id = #{uid}
    

3. 添加测试方法

    @Test
    public void testDeleteUser() throws Exception {
        //6.执行操作
        int res = userDao.deleteUser(52);
        System.out.println(res);
    }

用户模糊查询

1. 在持久层接口中添加模糊查询方法

    List findByName(String username);

2. 在用户的映射配置文件中配置

    
    
        select * from user where username like #{username}
    

3. 添加测试方法

    @Test
    public void testFindByName(){
        //5.执行查询一个方法
        List users = userDao.findByName("%王%");
        for(User user : users){
        System.out.println(user);
    }

4. 模糊查询的另一种配置方式

   1. 修改SQL语句的配置，如下

       
       
           select * from user where username like '%${value}%'
       

      将原来的 #{} 占位符，改成了 ${value} 。注意如果用模糊查询的这种写法，那么 ${value} 的写法就是固定的，不能写成其它名字。

   2. 测试

       @Test
       public void testFindByName(){
           //5.执行查询一个方法
           List users = userDao.findByName("王");
           for(User user : users){
           System.out.println(user);
           }
       } 

5. #{} 与 ${} 的区别

   • #{} 表示一个占位符号

     通过 #{} 可以实现 preparedStatement 向占位符中设置值，自动进行 java 类型和 jdbc 类型转换，
     #{}可以有效防止 sql 注入。 #{} 可以接收简单类型值或 pojo 属性值。 如果 parameterType 传输单个简单类
     型值，#{} 括号中可以是 value 或其它名称。

   • ${} 表示拼接 sql 串

     通过 ${} 可以将 parameterType 传入的内容拼接在 sql 中且不进行 jdbc 类型转换， ${} 可以接收简
     单类型值或 pojo 属性值，如果 parameterType 传输单个简单类型值， ${} 括号中只能是 value。

查询使用聚合函数

1. 在持久层接口中添加模糊查询方法

    int findTotal();

2. 在用户的映射配置文件中配置

    
    
        select count(*) from user;
    

3. 添加测试方法

    @Test
    public void testFindTotal() throws Exception {
        //6.执行操作
        int res = userDao.findTotal();
        System.out.println(res);
    }

Mybatis与JDBC编程的比较

1. 数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。

   解决：
   在 SqlMapConfig.xml 中配置数据链接池，使用连接池管理数据库链接。

2. Sql 语句写在代码中造成代码不易维护，实际应用 sql 变化的可能较大， sql 变动需要改变 java 代码。

   解决：
   将 Sql 语句配置在 XXXXmapper.xml 文件中与 java 代码分离。

3. 向 sql 语句传参数麻烦，因为 sql 语句的 where 条件不一定，可能多也可能少，占位符需要和参数对应。

   解决：
   Mybatis 自动将 java 对象映射至 sql 语句，通过 statement 中的 parameterType 定义输入参数的
   类型。

4. 对结果集解析麻烦， sql 变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成 pojo 对
   象解析比较方便。

   解决：
   Mybatis 自动将 sql 执行结果映射至 java 对象，通过 statement 中的 resultType 定义输出结果的
   类型。

Mybatis的参数深入

parameterType配置参数

1. SQL 语句传参，使用标签的 parameterType 属性来设定。该属性的取值可以是基本类型，引用类型（例如:String 类型），还可以是实体类类型（POJO 类）。同时也可以使用实体类的包装类

2. 注意

   基本类型和String我们可以直接写类型名称，也可以使用包名.类名的方式，例如：
   java.lang.String。

   实体类类型，目前我们只能使用全限定类名。

   究其原因，是 mybaits 在加载时已经把常用的数据类型注册了别名，从而我们在使用时可以不写包名，
   而我们的是实体类并没有注册别名，所以必须写全限定类名。

   参考 TypeAliasRegistery.class 的源码

传递 pojo 包装对象

开发中通过 pojo 传递查询条件 ，查询条件是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。

Pojo 类中包含 pojo。

需求：根据用户名查询用户信息，查询条件放到 QueryVo 的 user 属性中

1. 编写 QueryVo

    public class QueryVo implements Serializable {
        private User user;
        public User getUser() {
            return user;
        }
        public void setUser(User user) {
            this.user = user;
        }
    }

2. 编写持久层接口

    public interface IUserDao {
        /**
         * 根据 QueryVo 中的条件查询用户
         * @param vo
         * @return
         */
        List findByVo(QueryVo vo);
    }

3. 持久层接口的映射文件

    
    
        select * from user where username like #{user.username};
    

4. 测试包装类作为参数

    @Test
    public void testFindByQueryVo() {
        QueryVo vo = new QueryVo();
        User user = new User();
        user.setUserName("%王%");
        vo.setUser(user);
        List users = userDao.findByVo(vo);
        for(User u : users) {
            System.out.println(u);
        }
    }

Mybatis的输出结果封装

resultType配置结果类型

resultType 属性可以指定结果集的类型，它支持基本类型和实体类类型。

需要注意的是，它和 parameterType 一样，如果注册过类型别名的，可以直接使用别名。没有注册过的必须
使用全限定类名。例如：我们的实体类此时必须是全限定类名（今天最后一个章节会讲解如何配置实体类的别名）

同时，当是实体类名称是，还有一个要求，实体类中的属性名称必须和查询语句中的列名保持一致，否则无法实现封装

1. 基本类型示例

   Dao接口

    /**
     * 查询总记录条数
     * @return
     */
    int findTotal();

   映射配置

    
    
        select count(*) from user;
    

2. 实体类类型示例

   Dao接口

    /**
     * 查询所有用户
     * @return
     */
    List findAll();

   映射配置

    
    
        select * from user
    

3. 特殊情况示例

   实体类属性和数据库表的列名不一致

   修改映射配置

   使用别名查询

    
    
        select id as userId,username as userName,birthday as userBirthday, sex as userSex,address as userAddress from user
    

   如果查询很多，都使用别名的话写起来很麻烦

resultMap结果类型

resultMap 标签可以建立查询的列名和实体类的属性名称不一致时建立对应关系。从而实现封装。

在 select 标签中使用 resultMap 属性指定引用即可。同时 resultMap 可以实现将查询结果映射为复杂类型的 pojo，比如在查询结果映射对象中包括 pojo 和 list 实现一对一查询和一对多查询

1. 定义 resultMap

    
    
        
        
        
        
        
    
   
    说明：
    id 标签：用于指定主键字段
    result 标签：用于指定非主键字段
    column 属性：用于指定数据库列名
    property 属性：用于指定实体类属性名称

2. 映射配置

    
    
        select * from user
    

SqlMapConfig.xml配置文件

配置内容

1. SqlMapConfig.xml中配置的内容和顺序

    -properties（属性）
        --property
    -settings（全局配置参数）
        --setting
    -typeAliases（类型别名）
        --typeAliase
        --package
    -typeHandlers（类型处理器）
    -objectFactory（对象工厂）
    -plugins（插件）
    -environments（环境集合属性对象）
        --environment（环境子属性对象）
            ---transactionManager（事务管理）
            ---dataSource（数据源）
    -mappers（映射器）
        --mapper
        --package

properties（属性）

在使用 properties 标签配置时，我们可以采用两种方式指定属性配置。

1. 第一种

2. 第二种

   1. 在classpath下定义db.properties文件

       jdbc.driver=com.mysql.jdbc.Driver
       jdbc.url=jdbc:mysql://localhost:3306/db_mybatis
       jdbc.username=root
       jdbc.password=mysql

   2. properties标签配置

   3. 此时我们的dataSource标签就编程了引用上面的配置

typeAliases（类型别名）

采用自定义别名方式

1. 自定义别名

   在 SqlMapConfig.xml 中配置：

mappers（映射器）

1. 使用相对于类路径的资源，如：

2. 使用mapper接口类路径，如：

   注意：此种方法要求mapper接口名称和mapper映射文件名称相同，且放在用一个目录中。

3. 注册指定包下的所有mapper接口，如：

   注意：此种方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中

Mybatis连接池与事务深入

Mybatis的连接池技术

SqlMapConfig.xml 配置文件中， 通过 来实现 Mybatis 中连接池的配置

1. Mybatis连接池的分类

   Mybatis将数据源分为三类：

   • UNPOOLED 不使用连接池的数据源
   • POOLED 使用连接池的数据源
   • JNDI 使用 JNDI 实现的数据源

2. Mybatis中数据源的配置

   SqlMapConfig.xml

   MyBatis 在初始化时， 根据 的 type 属性来创建相应类型的的数据源 DataSource，即：

   type=”POOLED”： MyBatis 会创建 PooledDataSource 实例

   type=”UNPOOLED” ： MyBatis 会创建 UnpooledDataSource 实例

   type=”JNDI”： MyBatis 会从 JNDI 服务上查找 DataSource 实例，然后返回使用

3. Mybatis中DataSource的存取

   MyBatis是通过工厂模式来创建数据源DataSource对象的，MyBatis定义了抽象的工厂接口: org.apache.ibatis.datasource.DataSourceFactory,通过其 getDataSource()方法返回数据源 DataSource。

4. Mybatis中连接的获取过程分析

   当我们需要创建 SqlSession 对象并需要执行 SQL 语句时，这时候 MyBatis 才会去调用 dataSource 对象来创建java.sql.Connection对象。也就是说， java.sql.Connection对象的创建一直延迟到执行SQL语句的时候。

    @Test
    public void testSql() throws Exception {
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = factory.openSession();
        List list = sqlSession.selectList("findUserById",41);
        System.out.println(list.size());
    }

   只有当第 4 句 sqlSession.selectList("findUserById")，才会触发 MyBatis 在底层执行下面这个方法来创建 java.sql.Connection 对象

Mybatis的事务控制

1. JDBC中的事务控制

   在 JDBC 中我们可以通过手动方式将事务的提交改为手动方式，通过 setAutoCommit()方法就可以调整。

2. Mybatis中事务提交方式

   Mybatis 中事务的提交方式，本质上就是调用 JDBC 的 setAutoCommit()来实现事务控制。

3. Mybatis 自动提交事务的设置

    //创建 SqlSession 对象
    session = factory.openSession(true);

Mybatis的动态SQL语句

标签

根据实体类的不同取值，使用不同的 SQL 语句来进行查询。比如在 id 如果不为空时可以根据 id 查询，如果 username 不同空时还要加入用户名作为条件。这种情况在多条件组合查询中经常会碰到。

1. 持久层Dao接口

    List findByUser(User user);

2. 持久层Dao映射配置

    
        select * from user where 1=1
        
            and username like #{username}
        
        
            and address like #{address}
        
    

   注意： 标签的 test 属性中写的是对象的属性名，如果是包装类的对象要使用 OGNL 表达式的写法。
   另外要注意 where 1=1 的作用

3. 测试

    @Test
    public void testFindByUser() {
        User u = new User();
        u.setUsername("%王%");
        u.setAddress("%顺义%");
        //6.执行操作
        List users = userDao.findByUser(u);
        for(User user : users) {
            System.out.println(user);
        }
    }

标签

为了简化上面 where 1=1 的条件拼装，我们可以采用 标签来简化开发

1. 持久层Dao映射配置

    
    
        
        
            
                and username like #{username}
            
            
                and address like #{address}
            
        
    

   标签

2. 需求

   传入多个 id 查询用户信息，用下边两个 sql 实现：

    SELECT * FROM USERS WHERE username LIKE '%张%' AND (id =10 OR id =89 OR id=16)
    SELECT * FROM USERS WHERE username LIKE '%张%' AND id IN (10,89,16)

   这样在进行范围查询时，就要将一个集合中的值，作为参数动态添加进来。

   1. 在 QueryVo 中加入一个 List 集合用于封装参数

       public class QueryVo implements Serializable {
           private List ids;
           public List getIds() {
               return ids;
           }
           public void setIds(List ids) {
               this.ids = ids;
           }
       }

3. 持久层接口

    List findInIds(QueryVo vo);

4. 持久层Dao映射配置

    
    
    
        
        
            
                
                    #{uid}
                
            
        
    

   SQL语句：

    select 字段 from user where id in (?)

   标签用于遍历集合，它的属性：

    collection:代表要遍历的集合元素，注意编写时不要写#{}
    open:代表语句的开始部分
    close:代表结束部分
    item:代表遍历集合的每个元素，生成的变量名
    sperator:代表分隔符

Mybatis中简化编写的SQL片段

Sql 中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的

1. 定义代码片段

    
    
        select * from user
    

2. 引用代码片段

    
    
        
    
   
    
    
        
        where id = #{uid}
    

Mybatis多表查询之 一对多

本次案例主要以最为简单的用户和账户的模型来分析 Mybatis 多表关系。用户为 User 表，账户为Account表。一个用户（User）可以有多个账户（Account）

一对一查询（多对一）

需求

查询所有账户信息，关联查询下单用户信息。

注意：

因为一个账户信息只能供某个用户使用，所以从查询账户信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的账户信息则为一对多查询，因为一个用户可以有多个账户

1. 方式一

   1. 定义账户信息的实体类

       public class Account implements Serializable {
           private Integer id;
           private Integer uid;
           private Double money;
           public Integer getId() {
               return id;
           }
           public void setId(Integer id) {
               this.id = id;
           }
           public Integer getUid() {
               return uid;
           }
           public void setUid(Integer uid) {
               this.uid = uid;
           }
           public Double getMoney() {
               return money;
           }
           public void setMoney(Double money) {
               this.money = money;
           }
           @Override
           public String toString() {
               return "Account [id=" + id + ", uid=" + uid + ", money=" + money + "]";
           }
       }

   2. 编写sql语句

      实现查询账户信息时，也要查询账户所对应的用户信息

       SELECT
           account.*,
           user.username,
           user.address
       FROM
           account,
           user
       WHERE account.uid = user.id

   3. 定义 AccountUser 类

      为了能够封装上面 SQL 语句的查询结果，定义 AccountCustomer 类中要包含账户信息同时还要包含用户信息，所以我们要在定义 AccountUser 类时可以继承 User 类。

       public class AccountUser extends Account implements Serializable {
           private String username;
           private String address;
           public String getUsername() {
               return username;
           }
           public void setUsername(String username) {
               this.username = username;
           }
           public String getAddress() {
               return address;
           }
           public void setAddress(String address) {
               this.address = address;
           }
           @Override
           public String toString() {
               return super.toString() + " AccountUser [username=" + username + ", address=" + address + "]";
           }
       }

   4. 定义账户的持久层Dao接口

       List findAll();

   5. 定义 AccountDao.xml 文件中的查询配置信息

       
       
       
           
           
               select a.*,u.username,u.address from account a,user u where a.uid =u.id;
           
       

      注意：因为上面查询的结果中包含了账户信息同时还包含了用户信息，所以我们的返回值类型 returnType 的值设置为 AccountUser 类型，这样就可以接收账户信息和用户信息了。

   6. 测试

   7. 小结

      定义专门的 po 类作为输出类型，其中定义了 sql 查询结果集所有的字段。此方法较为简单，企业中使用普遍。

2. 方式二

   使用 resultMap，定义专门的 resultMap 用于映射一对一查询结果。

   通过面向对象的(has a)关系可以得知，我们可以在 Account 类中加入一个 User 类的对象来代表这个账户是哪个用户的

   1. 修改Account类

      在 Account 类中加入 User 类的对象作为 Account 类的一个属性。

   2. 修改 AccountDao 接口中的方法

       List findAll();

      注意：第二种方式，将返回值改 为了 Account 类型。因为 Account 类中包含了一个 User 类的对象，它可以封装账户所对应的用户信息

   3. 重新定义 AccountDao.xml 文件

      
      
      
          
          
              
              
              
              
              
                  
                  
                  
                  
                  
              
          
          
              select u.*,a.id as aid,a.uid,a.money from account a,user u where a.uid =u.id;
          
      

   4. 测试

一对多查询

需求：

查询所有用户信息及用户关联的账户信息。

分析：

用户信息和他的账户信息为一对多关系，并且查询过程中如果用户没有账户信息，此时也要将用户信息查询出来，我们想到了左外连接查询比较合适

1. 编写SQL语句

    SELECT
        u.*, acc.id id,
        acc.uid,
        acc.money
    FROM
        user u
    LEFT JOIN account acc ON u.id = acc.uid

2. User 实体类加入 List

3. 用户持久层 Dao 接口中加入查询方法

    List findAll();

4. 用户持久层 Dao 映射文件配置

    
    
    
        
            
            
            
            
            
            
            
                
                
                
            
        
   
        
        
            select u.*,a.id as aid ,a.uid,a.money from user u left outer join account a on u.id =a.uid
        
    
   
   
    说明：
    collection
        部分定义了用户关联的账户信息。表示关联查询结果集
    property="accList"：
        关联查询的结果集存储在 User 对象的上哪个属性。
    ofType="account"：
        指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。

5. 测试

Mybatis多表查询之多对多

实现Role到User多对多

1. 业务要求及实现 SQL

   需求：

    实现查询所有对象并且加载它所分配的用户信息。

   分析：

    查询角色我们需要用到Role表，但角色分配的用户的信息我们并不能直接找到用户信息，而是要通过中间表(USER_ROLE 表)才能关联到用户信息。

   SQL

    SELECT
        r.*,u.id uid,
        u.username username,
        u.birthday birthday,
        u.sex sex,
        u.address address
    FROM
        ROLE r
    INNER JOIN
        USER_ROLE ur
    ON ( r.id = ur.rid)
    INNER JOIN
        USER u
    ON (ur.uid = u.id);

2. 编写角色实体类

    public class Role implements Serializable {
        private Integer roleId;
        private String roleName;
        private String roleDesc;
        //多对多的关系映射：一个角色可以赋予多个用户
        private List users;
        public List getUsers() {
            return users;
        }
        public void setUsers(List users) {
            this.users = users;
        }
        public Integer getRoleId() {
            return roleId;
        }
        public void setRoleId(Integer roleId) {
            this.roleId = roleId;
        }
        public String getRoleName() {
            return roleName;
        }
        public void setRoleName(String roleName) {
            this.roleName = roleName;
        }
        public String getRoleDesc() {
            return roleDesc;
        }
        public void setRoleDesc(String roleDesc) {
            this.roleDesc = roleDesc;
        }
        @Override
        public String toString() {
            return "Role{" + "roleId=" + roleId + ", roleName='" + roleName + '\'' + ", roleDesc='" + roleDesc + '\'' + '}';
        }
    }

3. 编写Role持久层接口

    List findAll();

4. 编写映射文件

    
    
    
        
        
            
            
            
            
                
                
                
                
                
            
        
   
        
        
            select u.*,r.id as rid,r.role_name,r.role_desc from role r
            left outer join user_role ur on r.id = ur.rid
            left outer join user u on u.id = ur.uid
        
    

5. 测试

实现User到Role的多对多

从 User 出发，我们也可以发现一个用户可以具有多个角色，这样用户到角色的关系也还是一对多关系。这样我们就可以认为 User 与 Role 的多对多关系，可以被拆解成两个一对多关系来实现。

Mybatis 延迟加载策略

何为延迟加载

1. 延迟加载：

   就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载.好处： 先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。

2. 坏处：

   因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗时间，所以可能造成用户等待时间变长，造成用户体验下降。

实现需求

查询账户(Account)信息并且关联查询用户(User)信息。如果先查询账户(Account)信息即可满足要求，当我们需要查询用户(User)信息时再查询用户(User)信息。把对用户(User)信息的按需去查询就是延迟加载。

使用 assocation 实现延迟加载

1. 账户的持久层DAO接口

    List findAll();

2. 账户的持久层映射文件

    
    
    
        
        
            
            
            
            
            
            
        
        
            select * from account
        
    
   
    说明：
    select： 填写我们要调用的 select 映射的 id
    column ： 填写我们要传递给 select 映射的参数

3. 用户的持久层接口和映射文件

    public interface IUserDao {
    /**
     * 根据 id 查询
     * @param userId
     * @return
     */
    User findById(Integer userId);
    }
   
   
    
    
    
        
        
            select * from user where id = #{uid}
        
    

4. 开启Mybatis的延迟加载策略

   在 Mybatis 的配置文件 SqlMapConfig.xml 文件中添加延迟加载的配置。

使用 Collection 实现延迟加载

在一对多关系配置的结点中配置延迟加载策略。

结点中也有 select 属性， column 属性。

1. 在 User 实体类中加入 List属性

2. 编写用户和账户持久层接口的方法

    List findByUid(Integer uid);

3. 编写用户持久层映射配置

    
        
        
        
        
        
        
        
        
    
   
    
    
        select * from user
    
   
   
    说明：
    标签：
    主要用于加载关联的集合对象
    select 属性：
    用于指定查询 account 列表的 sql 语句，所以填写的是该 sql 映射的 id
    column 属性：
    用于指定 select 属性的 sql 语句的参数来源，上面的参数来自于 user 的 id 列，所以就写成 id 这一个字段名了

4. 编写账户持久层映射配置

    
    
        select * from account where uid = #{uid}
    

Mybatis缓存

Mybatis一级缓存

一级缓存是 SqlSession 级别的缓存，只要 SqlSession 没有 flush 或 close，它就存在。

1. 一级缓存的分析

   一级缓存是 SqlSession 范围的缓存，当调用 SqlSession 的修改，添加，删除， commit()， close()等方法时，就会清空一级缓存。

Mybatis二级缓存

二级缓存是 mapper 映射级别的缓存，多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句，多个SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的。

1. 二级缓存的开启与关闭

   1. 在 SqlMapConfig.xml 文件开启二级缓存

      因为 cacheEnabled 的取值默认就为 true，所以这一步可以省略不配置。为 true 代表开启二级缓存；为
      false 代表不开启二级缓存。

   2. 配置相关的 Mapper 映射文件

      标签表示当前这个 mapper 映射将使用二级缓存，区分的标准就看 mapper 的 namespace 值。

   3. 配置 statement 上面的 useCache 属性

       
       
           select * from user where id = #{uid}
       

      将 UserDao.xml 映射文件中的标签中设置 useCache=”true”代表当前这个 statement 要使用二级缓存，如果不使用二级缓存可以设置为 false。

      注意： 针对每次查询都需要最新的数据 sql，要设置成 useCache=false，禁用二级缓存。

      二级缓存注意事项

      当我们在使用二级缓存时，所缓存的类一定要实现 java.io.Serializable 接口，这种就可以使用序列化方式来保存对象。

      Mybatis 注解开发

      mybatis 的常用注解说明

      @Insert:实现新增
      @Update:实现更新
      @Delete:实现删除
      @Select:实现查询
      @Result:实现结果集封装
      @Results:可以与@Result 一起使用，封装多个结果集
      @ResultMap:实现引用@Results 定义的封装
      @One:实现一对一结果集封装
      @Many:实现一对多结果集封装
      @SelectProvider: 实现动态 SQL 映射
      @CacheNamespace:实现注解二级缓存的使用

      使用 Mybatis 注解实现基本 CRUD

      1. 使用注解方式开发持久层接口

         1. 查询所有用户

             @Select("select * from user")
             @Results(id="userMap",
                 value= {
                     @Result(id=true,column="id",property="userId"),
                     @Result(column="username",property="userName"),
                     @Result(column="sex",property="userSex"),
                     @Result(column="address",property="userAddress"),
                     @Result(column="birthday",property="userBirthday")
                 })
             List findAll();

         2. 根据 id 查询一个用户

             @Select("select * from user where id = #{uid} ")
             @ResultMap("userMap")
             User findById(Integer userId);

         3. 保存操作

             @Insert("insert into user(username,sex,birthday,address)values(#{username},#{sex},#{birthday},#{address}
             )")
             @SelectKey(keyColumn="id",keyProperty="id",resultType=Integer.class,before = false, statement = { "select last_insert_id()" })
             int saveUser(User user);

         4. 更新操作

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

         5. 删除用户

             @Delete("delete from user where id = #{uid} ")
             int deleteUser(Integer userId);

         6. 查询使用聚合函数

             @Select("select count(*) from user ")
             int findTotal();

         7. 模糊查询

             @Select("select * from user where username like #{username} ")
             List findByName(String name);

      2. 编写 SqlMapConfig 配置文件

      使用注解实现复杂关系映射开发

      实现复杂关系映射之前我们可以在映射文件中通过配置 来实现， 在使用注解开发时我们需要借助@Results 注解， @Result 注解， @One 注解， @Many 注解。

      1. 复杂关系映射的注解说明

          @Results 注解
          代替的是标签
          该注解中可以使用单个@Result 注解，也可以使用@Result 集合
          @Results（{@Result（）， @Result（） }）或@Results（@Result（））
         
          @Resutl 注解
          代替了 标签和标签
          @Result 中 属性介绍：
              id 是否是主键字段
              column 数据库的列名
              property 需要装配的属性名
              one 需要使用的@One 注解（@Result（one=@One）（）））
              many 需要使用的@Many 注解（@Result（many=@many）（）））
         
          @One 注解（一对一）
              代替了标签，是多表查询的关键，在注解中用来指定子查询返回单一对象。
          @One 注解属性介绍：
              select 指定用来多表查询的 sqlmapper
              fetchType 会覆盖全局的配置参数 lazyLoadingEnabled。。
          使用格式：
              @Result(column=" ",property="",one=@One(select=""))
         
          @Many 注解（多对一）
              代替了标签,是是多表查询的关键，在注解中用来指定子查询返回对象集合。
              注意：聚集元素用来处理“一对多”的关系。需要指定映射的 Java 实体类的属性，属性的 javaType（一般为 ArrayList）但是注解中可以不定义；
              使用格式：
                  @Result(property="",column="",many=@Many(select=""))

      2. 使用注解实现一对一复杂关系映射及延迟加载

         需求：

         加载账户信息时并且加载该账户的用户信息，根据情况可实现延迟加载。（注解方式实现）

         1. 添加 User 实体类及 Account 实体类

             public class User implements Serializable {
                 private Integer userId;
                 private String userName;
                 private Date userBirthday;
                 private String userSex;
                 private String userAddress;
             }
            
             public class Account implements Serializable {
                 private Integer id;
                 private Integer uid;
                 private Double money;
                 //多对一关系映射：从表方应该包含一个主表方的对象引用
                 private User user;
             }

         2. 添加账户的持久层接口并使用注解配置

             @Select("select * from account")
             @Results(id="accountMap",
                 value= {
                     @Result(id=true,column="id",property="id"),
                     @Result(column="uid",property="uid"),
                     @Result(column="money",property="money"),
                     @Result(column="uid",
                         property="user",
                         one=@One(select="com.xuexi.dao.IUserDao.findById",
                     fetchType=FetchType.LAZY)
                     )
                 })
             List findAll();

         3. 添加用户的持久层接口并使用注解配置

             @Select("select * from user")
             @Results(id="userMap",
                 value= {
                     @Result(id=true,column="id",property="userId"),
                     @Result(column="username",property="userName"),
                     @Result(column="sex",property="userSex"),
                     @Result(column="address",property="userAddress"),
                     @Result(column="birthday",property="userBirthday")
             })
             List findAll();
            
            
             @Select("select * from user where id = #{uid} ")
             @ResultMap("userMap")
             User findById(Integer userId);

      3. 使用注解实现一对多复杂关系映射

         需求：

         查询用户信息时，也要查询他的账户列表。使用注解方式实现。

         分析：

         一个用户具有多个账户信息，所以形成了用户(User)与账户(Account)之间的一对多关系。

         1. User 实体类加入 List

             public class User implements Serializable {
                 private Integer userId;
                 private String userName;
                 private Date userBirthday;
                 private String userSex;
                 private String userAddress;
                 //一对多关系映射：主表方法应该包含一个从表方的集合引用
                 private List accounts;
             }

         2. 编写用户的持久层接口并使用注解配置

             @Select("select * from user")
             @Results(id="userMap",
                 value= {
                     @Result(id=true,column="id",property="userId"),
                     @Result(column="username",property="userName"),
                     @Result(column="sex",property="userSex"),
                     @Result(column="address",property="userAddress"),
                     @Result(column="birthday",property="userBirthday"),
                     @Result(column="id",property="accounts",
                         many=@Many(
                             select="com.xuexi.dao.IAccountDao.findByUid",
                             fetchType=FetchType.LAZY
                             )
                         )
                 })
             List findAll();
            
            
             说明：
             @Many:
                 相当于的配置
                 select 属性：代表将要执行的 sql 语句
                 fetchType 属性：代表加载方式，一般如果要延迟加载都设置为 LAZY 的值

         3. 编写账户的持久层接口并使用注解配置

             @Select("select * from account where uid = #{uid} ")
             List findByUid(Integer userId);

      mybaits基于注解的二级缓存

      1. 在 SqlMapConfig 中开启二级缓存支持

      2. 在持久层接口中使用注解配置二级缓存

          @CacheNamespace(blocking=true)//mybatis 基于注解方式实现配置二级缓存
          public interface IUserDao {}

      你可能感兴趣的:(Mybatis学习)

      • Java学习-MyBatis学习(二) 丢爸 javajava学习mybatis
        代码下载MyBatis核心配置文件jdbc.driver=com.mysql.cj.jdbc.Driverjdbc.url=jdbc:mysql://192.168.29.201:3306/mybatisjdbc.username=rootjdbc.password=123456-->-->设置配置文件模板①复制要创建模板的配置文件内容②③MyBatis获取参数值Mybatis获取参数值的两种方式
      • [000-01-011].第2节：持久层方案的对比 1.01^1000 [000-01].Java笔记java-ee
        我的后端学习大纲MyBatis学习大纲1.持久层解决方案：1.1.面试1：请说一说持久层解决方案有哪些？？？1.jdbcJDBC为访问不同的数据库提供了一种统一的途径，为开发者屏蔽了一些细节问题。Java程序员使用JDBC可以连接任何提供了JDBC驱动程序的数据库系统，这样就使得程序员无需对特定的数据库系统的特点有过多的了解，从而大大简化和加快了开发过程。2.DBUtils：DBUtils是一个小
      • MyBatis学习：创建工具类MyBatisUtil——整合简化代码量 你是我的日月星河 记录学习MyBatismybatis学习javamysql
        1、本篇博客的背景和目的目前我本人正在学习MyBatis框架，在原先了解并且懵懵懂懂使用的基础上，开始系统正式的学习。目前已经阐述了MVC架构模式和三层架构，明晰了在Web项目中的普遍编码层次，认识了框架，回顾了JDBC连接数据库，介绍了MyBatis框架，初步建立了使用MyBatis和MySQL的Maven项目，简单解释了STDOUT_LOGGING日志和INSERT语句手动提交事务，记录了My
      • SSM详细速成 一叉树 mybatisjavamysqlspringmvc
        ssm速成此文对狂神说ssm整合进行解读mybatis学习+测试pojo.Books@AllArgsConstructor@NoArgsConstructor@DatapublicclassBooks{privateintbookId;privateStringbookName;privateintbookCounts;privateStringdetail;}mybatis.xml核心文件设置连
      • 4.MyBatis学习之MyBatis-config.xml配置文件详解 Mr_junjun MyBatismybatis
        目录MyBatis配置文件结构1.属性（Properties）2.设置（settings）3.类型别名（typeAliases）4.类型处理器(typeHandlers)5.插件（plugins）拦截器6.environments（环境）7.映射器（mappers）MyBatis配置文件结构MyBatis框架包括两种XML类型的文件，1）配置文件：即mybatis-config.xml2）映射文件
      • MyBatis学习08-XML配置文件 还有头发的老李 MyBatisjavamybatis
        MyBatis学习08-XML配置文件1概述2配置文件头部声明3properties（属性）4settings（设置）5typeAliases（类型别名）6typeHandlers（类型处理器）7objectFactory（对象工厂）8plugins（插件）9environments（环境配置）10mappers（映射器）1概述MyBatis中的XML配置文件指的是mybatis-config.x
      • Mybatis学习笔记--延迟加载与缓存 龙源lll Mybatis数据库mybatismysqljava
        Mybatis学习笔记：Mybatis的概念与入门案例自定义MybatisMybatis实现CRUD动态SQL语句多表查询延迟加载与缓存注解开发Mybatis中的延迟加载什么是延迟加载在一对多的表的操作中，存在着多个用户与账户，那么在查询用户时，需不需要我们将其所有关联的账户同时查询出来？当我们查询账户时，需不需要我们把其关联的用户查询出来？这时我们会发现，当查询一个用户时，其账户信息应该是，什么
      • Mybatis学习笔记 保护壳 后端javamybatis
        MyBatis一、简介1.1什么是MybatisMyBatis是一款优秀的持久层框架MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。MyBatis可以通过简单的XML或注解来配置和映射原始类型、接口和JavaPOJO（PlainOldJavaObjects，普通老式Java对象）为数据库中的记录如何获得Mybatis?maven仓库org.mybatismybatis3.
      • mybatis学习笔记重点梳理 蓝天⊙白云 数据库数据库sql
        Mybatis温习笔记如果使用注解和XML文件两种方式同时定义，那么XML方式将覆盖掉注解方式。${}与#{}的区别（1）#{}是参数占位符，即预编译。解析时将传入的数据都当成一个字符串，会对传入的变量自动加一个单引号。如：user_id=#{userId}，如果传入的值是111，那么解析成sql时的值为user_id=‘111’，如果传入的值是id，则解析成的sql为user_id=‘id’。（
      • Mybatis简单梳理 木子六日 javamybatisjava数据库ssm后端
        Mybatis学习笔记author：木子六日文章目录Mybatis学习笔记author：木子六日DAY1基本配置映射文件的配置DAY2数据库连接池的配置文件log4j的配置文件给pojo类设置别名简单的查询与插入使用DAY3Mapper的接口绑定多参数动态sql补充DAY1mybatis是一个持久层框架，是为了简化dao层开发的一个框架。基本配置注意原来的com.dao和com.dao.impl这
      • MyBatis学习笔记(二) 疯狂的社畜
        MyBatis学习笔记(二)mybatis的curd(基于代理dao的方式)1、实体类publicclassUserimplementsSerializable{privateIntegercid;privateIntegerage;privateStringusername;privateStringaddress;privateStringsex;privateDatebirthday;pub
      • Mybatis学习笔记 ZeroZuo
        一、中文学习文档链接地址  https://mybatis.org/mybatis-3/zh/getting-started.html二、准备要使用myBatis，要导入两个依赖，一个是myBatis包，一个是myBatis驱动包。mysqlmysql-connector-java8.0.20org.mybatismybatis3.2.6或者org.mybatis.spring.bootmybat
      • Mybatis学习笔记 不爱吃橘子7 mybatismybatis
        Mybatis1.快速入门（xml文件配置形式）1.创建实体类2.引入jar包3.编写全局配置文件4.编写mapper.xml映射文件(放在类路径下)5.数据库和log4j配置文件6.测试7.结果2.通过接口来实现1.添加接口Mapper2.修改UserMapper.xml配置文件3.将UserMapper.xml加到全局配置文件中，接口不需要加4.测试3.Mybatis全局配置1.引入dtd约束
      • MyBatis学习二：Mapper代理开发、配置文件完成增删改查、注解开发 无知的小菜鸡 Java基础mybatis
        前言公司要求没办法，前端也要了解一下后端知识，这里记录一下自己的学习学习教程：黑马mybatis教程全套视频教程，2天Mybatis框架从入门到精通文档：https://mybatis.net.cn/index.htmlMapper代理开发目的解决原生方式中的硬编码简化后期执行sqlMapper代理要求定义与sql映射文件同名的Mapper接口，并且将Mapper接口和sql映射文件放置在同一目录
      • MyBatis学习一：快速入门 无知的小菜鸡 Java基础mybatis
        前言公司要求没办法，前端也要了解一下后端知识，这里记录一下自己的学习学习教程：黑马mybatis教程全套视频教程，2天Mybatis框架从入门到精通文档：https://mybatis.net.cn/index.htmlMyBatis快速入门：查询user表中所有数据创建user表，添加数据创建模块，导入坐标编写mybatis核心配置文件---->替换连接信息，解决硬编码问题编写sql映射文件—>
      • MyBatis学习总结 阿敏MIN
        一、认识mybatismybatis是一个持久层框架（dao-数据库操作）Github源码mybatis官方文档-最佳参考文档二、helloworld【入门】配置1.mybatis配置（必配）⑴.加载mybatis的jar包（mybatis-3.4.5）|mysql驱动包⑵.开发mybatis核心配置文件（mybatis-conf.xml）-数据链接池配置，映射文件等mybatis配置文件格式（*
      • MyBatis学习笔记-注解SQL多个参数查询异常处理 人生偌只如初见 J2EEBatisMyBatisSQL多参数注解
        MyBatis注解SQL查询，单个参数无需处理可以正常返回结果@Select("SELECT*FROMUSERWHEREACCOUNT=#{account}")UserreadUserByAccount(Stringaccount)throwsDataAccessException;多个参数查询不做处理会报异常@Select("SELECT*FROMUSERWHEREACCOUNT=#{accou
      • MyBatis中如何接收String类型的参数 完美主义编程小白 java后端
        在MyBatis学习初期，当parameterType的值为String也就是接收String类型的参数时，我会通过value来接，如图：通过value接收String类型的值舒适又简单，然而，直到有一天，我发现屡试不爽的value不给力了—>接收String类型值的时候出了问题。到底是什么凶残吓到了我的value—>就是标签，大家请看：这是配套数据表查出来的结果让我很费解，用value接收值的时
      • mybatis学习笔记1----入门介绍 mutang
        第1章框架概述什么是框架框架其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。简单说就是使用别人搭好的舞台，你来做表演。而且，框架一般是成熟的，不断升级的软件。框架要解决的问题框架要解决的最重要的一个问题是技术整合的问题，在J2EE的框架中，有着各种各样的技术，不同的软件企业需要从J2EE中选择不同的技术，这就使得软件企业最终的应用依赖于这些技术，技术自身的复杂性和技术的风险性将会
      • MyBatis学习之路——获取参数值和各种查询功能（查询实体类、List集合、Map集合） 宏夏c MyBatismybatissqljava
        一、MyBatis获取参数值的两种方式（重点）MyBatis获取参数值的两种方式：${}和#{}${}的本质就是字符串拼接，#{}的本质就是占位符赋值${}使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号；但是#{}使用占位符赋值的方式拼接sql，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号1、单个字面量类型的参数注意：若mapper接口
      • 狂神说MyBatis学习笔记（自整理自用） 发际线码农 intellij-ideajavamybatis
        MyBatisMyBatis官网地址：https://mybatis.org/mybatis-3/MyBatis官网中文版：https://mybatis.org/mybatis-3/zh/index.html1、使用MyBatis之前的配置第一步：在Maven项目中配置MyBatis依赖（pom.xml文件）org.mybatismybatisx.x.x第二步：配置mybatis-config.
      • 【MyBatis学习笔记】MyBatis基础学习 Augenstern K MyBatismybatis学习笔记
        MyBatis基础MyBatis简介MyBatis特性MyBatis下载和其他持久化层技术对比核心配置文件详解默认的类型别名搭建MyBatis开发环境创建maven工程创建MyBatis的核心配置文件创建mapper接口创建MyBatis的映射文件通过junit测试功能加入log4j日志功能MyBatis获取参数值的两种方式（重点）单个字面量类型的参数多个字面量类型的参数map集合类型的参数实体类
      • 框架 —— MyBatis ShareBeHappy_Qin Javamybatis
        目录MyBatismybatis的环境搭建环境搭建的注意事项MyBatis的工作原理MyBatis的核心组件MyBatis学习网址：http://c.biancheng.net/mybatis/https://www.w3cschool.cn/mybatis/7zy61ilv.html下载：https://github.com/mybatis/mybatis-3/releasesmybatis是一
      • MyBatis学习笔记 | MyBatis的下载、编写一个HelloWorld的MyBatis、使用接口式编程改进HelloWorld 一颗白菜_
        MyBatis是一个半自动化，轻量级的持久化层框架，实现了Sql与Java编码分离，功能边界清晰，一个专注业务、一个专注数据。且sql是由开发人员控制的。MyBatis下载MyBatis的官方文档：https://mybatis.org/mybatis-3/。MyBatis的下载在GitHub中：https://github.com/mybatis/mybatis-3点此下载。点此链接进去，然后就
      • MyBatis学习笔记 qq_1532145264 数据库mybatis学习笔记mysqlsql数据库数据库开发
        MyBatis中文网：https://mybatis.net.cn/1什么是MyBatis？MyBatis是一款优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。MyBatis可以通过简单的XML或注解来配置和映射原始类型、接口和JavaPOJO（PlainOldJavaObjects，普通老式Java对象）为数据
      • MyBatis学习：MyBatis分页插件PageHelper的使用 ApesKingMan
        MyBatis的分页插件MyBatis的一个分页插件叫PageHelper。mysql中，分页的sql是使用limit来做，如果我们自己写sql，那分页肯定是没有任何问题的。但是一旦model多了起来，复杂了起来，我们很自然的想到使用mybatis的逆向工程来生成相应的po和mapper，但是同时也会带来弊端，比如这里的分页问题就不好解决了。可以修改生成的文件,是可行的，但是一般我们通过逆向工程生
      • Mybatis+SSM整合 Joker_DJ dear mybatis3mybatisspringjava
        Mybatis学习笔记简介MyBatis作用历史为什么要使用MyBatis？JDBCHibernateMybatisMyBatis入门程序1.创建jar工程2.导入jar包3.创建数据库4.建立关系映射类pojo5.创建核心配置文件SqlMappingConfig.xml6.创建与表对象的关系映射Mapping文件编写sql语句7.在核心配置文件当中引入Mapping8.创建工厂,执行sql语句M
      • MyBatis学习--mybatis开发dao的方法 IT职业与自媒体思考
        今天写了第1部分，明天Peter老师继续第2部分简介使用Mybatis开发Dao，通常有两个方法，即原始Dao开发方法和Mapper接口开发方法。主要概念介绍：MyBatis中进行Dao开发时候有几个重要的类，它们是SqlSessionFactoryBuilder、SqlSessionFactory、SqlSession。SqlSession中封装了对数据库的操作，如：查询、插入、更新、删除等。通
      • MyBatis学习笔记 thekingofjiecao
        MyBatis主配置文件1.Properties可以通过resource属性指定properties配置文件，而后，在配置文件中可以通过${}的方式访问properties里的数据2.Settings可以通过setting标签来设置属性。例：下面的配置可以将数据库中的下划线式命名法映射到POJO类的驼峰命名法。--------------------------------------------
      • SSM框架：Spring、Spring MVC、MyBatis学习 CC-CHEN springspringmvcmybatis开源框架SSM
        一、Spring开源框架Spring是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为J2EE应用程序开发提供集成的框架。图1.Spring框架的7个模块1.核心容器：核心容器提供Spring的基本功能。核心容器的主要组件时BeanFactory，BeanFactory使用控制反转IOC模式将应用程序的配置和依赖性规
      • Linux的Initrd机制 被触发 linux
        Linux 的 initrd 技术是一个非常普遍使用的机制，linux2.6 内核的 initrd 的文件格式由原来的文件系统镜像文件转变成了 cpio 格式，变化不仅反映在文件格式上， linux 内核对这两种格式的 initrd 的处理有着截然的不同。本文首先介绍了什么是 initrd 技术，然后分别介绍了 Linux2.4 内核和 2.6 内核的 initrd 的处理流程。最后通过对 Lin
      • maven本地仓库路径修改 bitcarter maven
        默认maven本地仓库路径：C:\Users\Administrator\.m2 修改maven本地仓库路径方法：     1.打开E:\maven\apache-maven-2.2.1\conf\settings.xml     2.找到        
      • XSD和XML中的命名空间 darrenzhu xmlxsdschemanamespace命名空间
        http://www.360doc.com/content/12/0418/10/9437165_204585479.shtml http://blog.csdn.net/wanghuan203/article/details/9203621 http://blog.csdn.net/wanghuan203/article/details/9204337 http://www.cn
      • Java 求素数运算 周凡杨 java算法素数
        网络上对求素数之解数不胜数，我在此总结归纳一下，同时对一些编码，加以改进，效率有成倍热提高。 第一种：   原理: 6N(+-)1法         任何一个自然数，总可以表示成为如下的形式之一： 6N，6N+1，6N+2，6N+3，6N+4，6N+5 (N=0，1，2，…)   
      • java 单例模式 g21121 java
        想必单例模式大家都不会陌生，有如下两种方式来实现单例模式：   class Singleton { private static Singleton instance=new Singleton(); private Singleton(){} static Singleton getInstance() { return instance; }
      • Linux下Mysql源码安装 510888780 mysql
        1.假设已经有mysql-5.6.23-linux-glibc2.5-x86_64.tar.gz (1)创建mysql的安装目录及数据库存放目录       解压缩下载的源码包，目录结构，特殊指定的目录除外：           
      • 32位和64位操作系统 墙头上一根草 32位和64位操作系统
        32位和64位操作系统是指：CPU一次处理数据的能力是32位还是64位。现在市场上的CPU一般都是64位的，但是这些CPU并不是真正意义上的64 位CPU，里面依然保留了大部分32位的技术，只是进行了部分64位的改进。32位和64位的区别还涉及了内存的寻址方面，32位系统的最大寻址空间是2 的32次方= 4294967296（bit）= 4（GB）左右，而64位系统的最大寻址空间的寻址空间则达到了
      • 我的spring学习笔记10-轻量级_Spring框架 aijuans Spring 3
        一、问题提问：     → 请简单介绍一下什么是轻量级？     轻量级（Leightweight）是相对于一些重量级的容器来说的，比如Spring的核心是一个轻量级的容器，Spring的核心包在文件容量上只有不到1M大小，使用Spring核心包所需要的资源也是很少的，您甚至可以在小型设备中使用Spring。  
      • mongodb 环境搭建及简单CURD antlove WebInstallcurdNoSQLmongo
        一 搭建mongodb环境 1. 在mongo官网下载mongodb 2. 在本地创建目录 "D:\Program Files\mongodb-win32-i386-2.6.4\data\db" 3. 运行mongodb服务 [mongod.exe --dbpath "D:\Program Files\mongodb-win32-i386-2.6.4\data\
      • 数据字典和动态视图 百合不是茶 oracle数据字典动态视图系统和对象权限
        数据字典（data dictionary）是 Oracle 数据库的一个重要组成部分，这是一组用于记录数据库信息的只读（read-only）表。随着数据库的启动而启动,数据库关闭时数据字典也关闭   数据字典中包含   数据库中所有方案对象（schema object）的定义(包括表，视图，索引，簇，同义词，序列，过程，函数，包，触发器等等) 数据库为一
      • 多线程编程一般规则 bijian1013 javathread多线程java多线程
               如果两个工两个以上的线程都修改一个对象，那么把执行修改的方法定义为被同步的，如果对象更新影响到只读方法，那么只读方法也要定义成同步的。        不要滥用同步。如果在一个对象内的不同的方法访问的不是同一个数据，就不要将方法设置为synchronized的。
      • 将文件或目录拷贝到另一个Linux系统的命令scp bijian1013 linuxunixscp
        一.功能说明        scp就是security copy，用于将文件或者目录从一个Linux系统拷贝到另一个Linux系统下。scp传输数据用的是SSH协议，保证了数据传输的安全，其格式如下：        scp 远程用户名@IP地址：文件的绝对路径
      • 【持久化框架MyBatis3五】MyBatis3一对多关联查询 bit1129 Mybatis3
        以教员和课程为例介绍一对多关联关系，在这里认为一个教员可以叫多门课程，而一门课程只有1个教员教，这种关系在实际中不太常见，通过教员和课程是多对多的关系。   示例数据：   地址表：   CREATE TABLE ADDRESSES ( ADDR_ID INT(11) NOT NULL AUTO_INCREMENT, STREET VAR
      • cookie状态判断引发的查找问题 bitcarter formcgi
        先说一下我们的业务背景： 1.前台将图片和文本通过form表单提交到后台，图片我们都做了base64的编码，并且前台图片进行了压缩 2.form中action是一个cgi服务 3.后台cgi服务同时供PC，H5，APP 4.后台cgi中调用公共的cookie状态判断方法（公共的，大家都用，几年了没有问题） 问题：（折腾两天。。。。） 1.PC端cgi服务正常调用，cookie判断没
      • 通过Nginx,Tomcat访问日志(access log)记录请求耗时 ronin47
        一、Nginx通过$upstream_response_time $request_time统计请求和后台服务响应时间 nginx.conf使用配置方式： log_format main '$remote_addr - $remote_user [$time_local] "$request" ''$status $body_bytes_sent "$http_r
      • java-67- n个骰子的点数。 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。 bylijinnan java
        public class ProbabilityOfDice { /** * Q67 n个骰子的点数 * 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。 * 在以下求解过程中，我们把骰子看作是有序的。 * 例如当n=2时，我们认为（1，2）和（2，1）是两种不同的情况 */ private stati
      • 看别人的博客，觉得心情很好 Cb123456 博客心情
           以为写博客，就是总结，就和日记一样吧，同时也在督促自己。今天看了好长时间博客:    职业规划:    http://www.iteye.com/blogs/subjects/zhiyeguihua      android学习:    1.http://byandby.i
      • [JWFD开源工作流]尝试用原生代码引擎实现循环反馈拓扑分析 comsci 工作流
            我们已经不满足于仅仅跳跃一次，通过对引擎的升级，今天我测试了一下循环反馈模式，大概跑了200圈，引擎报一个溢出错误      在一个流程图的结束节点中嵌入一段方程，每次引擎运行到这个节点的时候，通过实时编译器GM模块，计算这个方程，计算结果与预设值进行比较，符合条件则跳跃到开始节点，继续新一轮拓扑分析，直到遇到
      • JS常用的事件及方法 cwqcwqmax9 js
        事件 描述 onactivate 当对象设置为活动元素时触发。 onafterupdate 当成功更新数据源对象中的关联对象后在数据绑定对象上触发。 onbeforeactivate 对象要被设置为当前元素前立即触发。 onbeforecut 当选中区从文档中删除之前在源对象触发。 onbeforedeactivate 在 activeElement 从当前对象变为父文档其它对象之前立即
      • 正则表达式验证日期格式 dashuaifu 正则表达式IT其它java其它
        正则表达式验证日期格式 function isDate(d){ var v = d.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/i); if(!v) { this.focus(); return false; } } <input value="2000-8-8" onblu
      • Yii CModel.rules() 方法 、validate预定义完整列表、以及说说验证 dcj3sjt126com yii
        public array rules () {return} array 要调用 validate() 时应用的有效性规则。 返回属性的有效性规则。声明验证规则，应重写此方法。 每个规则是数组具有以下结构：array('attribute list', 'validator name', 'on'=>'scenario name', ...validation
      • UITextAttributeTextColor = deprecated in iOS 7.0 dcj3sjt126com ios
        In this lesson we used the key "UITextAttributeTextColor" to change the color of the UINavigationBar appearance to white. This prompts a warning "first deprecated in iOS 7.0." Ins
      • 判断一个数是质数的几种方法 EmmaZhao Mathpython
        质数也叫素数，是只能被1和它本身整除的正整数，最小的质数是2，目前发现的最大的质数是p=2^57885161-1【注1】。 判断一个数是质数的最简单的方法如下： def isPrime1(n): for i in range(2, n): if n % i == 0: return False return True 但是在上面的方法中有一些冗余的计算，所以
      • SpringSecurity工作原理小解读 坏我一锅粥 SpringSecurity
          SecurityContextPersistenceFilter   ConcurrentSessionFilter   WebAsyncManagerIntegrationFilter   HeaderWriterFilter   CsrfFilter   LogoutFilter   Use
      • JS实现自适应宽度的Tag切换 ini JavaScripthtmlWebcsshtml5
        效果体验：http://hovertree.com/texiao/js/3.htm   该效果使用纯JavaScript代码，实现TAB页切换效果，TAB标签根据内容自适应宽度，点击TAB标签切换内容页。 HTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"
      • Hbase Rest API : 数据查询 kane_xie RESThbase
        hbase（hadoop）是用java编写的，有些语言（例如python）能够对它提供良好的支持，但也有很多语言使用起来并不是那么方便，比如c#只能通过thrift访问。Rest就能很好的解决这个问题。Hbase的org.apache.hadoop.hbase.rest包提供了rest接口，它内嵌了jetty作为servlet容器。   启动命令：./bin/hbase rest s
      • JQuery实现鼠标拖动元素移动位置（源码+注释） 明子健 jqueryjs源码拖动鼠标
        欢迎讨论指正！   print.html代码： <!DOCTYPE html> <html> <head> <meta http-equiv=Content-Type content="text/html;charset=utf-8"> <title>发票打印</title> &l
      • Postgresql 连表更新字段语法 update qifeifei PostgreSQL
        下面这段sql本来目的是想更新条件下的数据，可是这段sql却更新了整个表的数据。sql如下： UPDATE tops_visa.visa_order SET op_audit_abort_pass_date = now() FROM tops_visa.visa_order as t1 INNER JOIN tops_visa.visa_visitor as t2 ON t1.
      • 将redis,memcache结合使用的方案? tcrct rediscache
        公司架构上使用了阿里云的服务，由于阿里的kvstore收费相当高，打算自建，自建后就需要自己维护，所以就有了一个想法，针对kvstore(redis)及ocs(memcache)的特点，想自己开发一个cache层，将需要用到list，set，map等redis方法的继续使用redis来完成，将整条记录放在memcache下，即findbyid，save等时就memcache，其它就对应使用redi
      • 开发中遇到的诡异的bug wudixiaotie bug
        今天我们服务器组遇到个问题： 我们的服务是从Kafka里面取出数据，然后把offset存储到ssdb中，每个topic和partition都对应ssdb中不同的key，服务启动之后，每次kafka数据更新我们这边收到消息，然后存储之后就发现ssdb的值偶尔是-2,这就奇怪了，最开始我们是在代码中打印存储的日志，发现没什么问题，后来去查看ssdb的日志，才发现里面每次set的时候都会对同一个key

      按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他

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

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