解析Mybatis入门第三天

目的：使用mybatis对数据的一些标签的使用和表与表之间的一对多和多对一的查询方式。

　　　例如：if、where、foreach

前言：同样是使用idea创建一个普通的maven工程（如何创建一个普通的Maven工程可以参考入门第一天的详解）。

　　   数据库的使用和前两天的一样，除此之外，新添加两张表，方便后面对一对多和多对一的操作打基础。

同样先查看整个项目的结构：

开始进入代码编辑。。。

• 在前两次的使用的数据库的基础上创建两张表。

  CREATE TABLE `account` (
    `ID` int(11) NOT NULL COMMENT '编号',
    `UID` int(11) default NULL COMMENT '用户编号',
    `MONEY` double default NULL COMMENT '金额',
    PRIMARY KEY  (`ID`),
    KEY `FK_Reference_8` (`UID`),
    CONSTRAINT `FK_Reference_8` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  ​
  insert  into `account`(`ID`,`UID`,`MONEY`) values (1,1,1000),(2,2,1000),(3,2,2000);
  ----------------------------------------分割---------------------------------------------------
  
  CREATE TABLE `role` (
    `ID` int(11) NOT NULL COMMENT '编号',
    `ROLE_NAME` varchar(30) default NULL COMMENT '角色名称',
    `ROLE_DESC` varchar(60) default NULL COMMENT '角色描述',
    PRIMARY KEY  (`ID`)
  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  ​
  insert  into `role`(`ID`,`ROLE_NAME`,`ROLE_DESC`) values (1,'组长','管理整个组'),(2,'班主任','管理整个班级'),(3,'校长','管理整个学校');
  ​
  CREATE TABLE `user_role` (
    `UID` int(11) NOT NULL COMMENT '用户编号',
    `RID` int(11) NOT NULL COMMENT '角色编号',
    PRIMARY KEY  (`UID`,`RID`),
    KEY `FK_Reference_10` (`RID`),
    CONSTRAINT `FK_Reference_10` FOREIGN KEY (`RID`) REFERENCES `role` (`ID`),
    CONSTRAINT `FK_Reference_9` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  ​
  insert  into `user_role`(`UID`,`RID`) values (1,1),(1,2),(2,2);

• 在项目的pom.xml文件中引入本次需要的坐标

    <dependencies>
           <!-- mybatis坐标 -->
           <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
           <dependency>
               <groupId>org.mybatis</groupId>
               <artifactId>mybatis</artifactId>
               <version>3.4.5</version>
           </dependency>
           <!--mysql驱动包-->
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
               <version>5.1.6</version>
           </dependency>
           <!--单元测试-->
           <dependency>
               <groupId>junit</groupId>
               <artifactId>junit</artifactId>
               <version>4.10</version>
               <scope>test</scope>
           </dependency>
           <!-- https://mvnrepository.com/artifact/log4j/log4j -->
           <!--日志-->
           <dependency>
               <groupId>log4j</groupId>
               <artifactId>log4j</artifactId>
               <version>1.2.17</version>
           </dependency>
       </dependencies>

• 配置需要的文件，在resources的文件下添加一个日志属性文件：log4j.properties

  # Set root category priority to INFO and its only appender to CONSOLE.
  #log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
  log4j.rootCategory=debug, CONSOLE
  
  # Set the enterprise logger category to FATAL and its only appender to CONSOLE.
  log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
  
  # CONSOLE is set to be a ConsoleAppender using a PatternLayout.
  log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
  log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
  log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
  
  # LOGFILE is set to be a File appender using a PatternLayout.
  log4j.appender.LOGFILE=org.apache.log4j.FileAppender
  #log4j.appender.LOGFILE.File=d:\axis.log
  log4j.appender.LOGFILE.File=axis.log
  log4j.appender.LOGFILE.Append=true
  log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
  log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

• 同样是在resources的目录下添加一个连接数据库的属性文件，配置数据库的连接：jdbc.properties

  driver=com.mysql.jdbc.Driver
  url=jdbc:mysql://127.0.0.1:3306/javaDemo?characterEncoding=utf8
  username=root
  password=root

• 最后在resources下配置最最最重要的文件：SqlMapConfig.xml。具体的讲解在文件中看注释

   <?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>
       <!--加载jdbc的属性配置文件-->
       <properties resource="jdbc.properties"/>
       <!--配置实体类的别名-->
       <typeAliases>
           <!--
           type:实体类的全路径
           alias：取的一个别名，不区分大小写，在配置文件调用这个实体类的时候就可以使用别名。
           -->
           <typeAlias type="zh.test.domain.NBAPlaers" alias="nbaers"/>
           <typeAlias type="zh.test.domain.Account" alias="account"/>
           <typeAlias type="zh.test.domain.Role" alias="role"/>
           <!--同样上面的可以写为   ：    如果有多个实体类可以写为：包名。别名则就是【类名】-->
           <!--<package name="zh.test.domain"/>-->
       </typeAliases>
       <!--配置多个环境-->
       <environments default="mysql">
           <!--配置环境-->
           <environment id="mysql">
               <!--
               配置事物管理，使用本地的事物策略
               使用mysql数据库，事务管理方式
               1、手动提交事物/回滚事物  setAutoCommit（false），mybatis默认事物的管理方式
               2、自动提交事物，设置自动提交的方式，不推荐使用。
               -->
               <transactionManager type="JDBC"></transactionManager>
               <!--是否要是要连接池 POOLED：使用内置连接。   UNPOOLED：不使用连接池，底层创建连接池的方式。   使用JNDI连接池-->
               <dataSource type="POOLED">
                   <property name="driver" value="${driver}"/>
                   <property name="url" value="${url}"/>
                   <property name="username" value="${username}"/>
                   <property name="password" value="${password}"/>
                   <!--<property name="url" value="jdbc:mysql:///javaDemo"/>-->
               </dataSource>
           </environment>
       </environments>
       <!--引入映射的配置文件，在本配置文件加载的时候就会加载在这里你配置的文件-->
       <mappers>
           <mapper resource="mappers/Usermapper.xml"></mapper>
           <mapper resource="mappers/Accountmapper.xml"></mapper>
           <mapper resource="mappers/Rolemapper.xml"></mapper>
       </mappers>
   </configuration>

• 编写NBAPlaers、Role、Account的Java文件，注意在每个Java文件中都要实现

  Serializable的接口。
  Account.java：

   package zh.test.domain;
  
   import java.io.Serializable;
  
   public class Account implements Serializable {
       private Integer id;
       private Integer uid;
       private Double money;
       private NBAPlaers nbaPlaers;
  
       @Override
       public String toString() {
           return "Account{" +
                   "id=" + id +
                   ", uid=" + uid +
                   ", money=" + money +
                   ", nbaPlaers=" + nbaPlaers +
                   '}';
       }
  
       public NBAPlaers getNbaPlaers() {
           return nbaPlaers;
       }
  
       public void setNbaPlaers(NBAPlaers nbaPlaers) {
           this.nbaPlaers = nbaPlaers;
       }
  
       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;
       }
   }

  NBAplaers.java:

   package zh.test.domain;
  
   import java.io.Serializable;
   import java.util.Date;
   import java.util.List;
  
   /*
   编写一个User的实体类，并且实现Serializable接口，目的只是表示一个类的对象可以被序列化。
   什么是Serializable接口？
   一个对象序列化的接口，一个类只有实现了Serializable接口，他的对象才能被序列化
    */
   public class NBAPlaers implements Serializable {
       private  Integer id;
       private String username;
       private Date birthday;
       private String sex;
       private String address;
       private List<Integer> ids;
       private List<Account> accounts;
  
       public List<Account> getAccounts() {
           return accounts;
       }
  
       public void setAccounts(List<Account> accounts) {
           this.accounts = accounts;
       }
  
       public List<Integer> getIds() {
           return ids;
       }
  
       public void setIds(List<Integer> ids) {
           this.ids = ids;
       }
  
       @Override
       public String toString() {
           return "NBAPlaers{" +
                   "id=" + id +
                   ", username='" + username + '\'' +
                   ", birthday=" + birthday +
                   ", sex='" + sex + '\'' +
                   ", address='" + address + '\'' +
                   ", ids=" + ids +
                   ", accounts=" + accounts +
                   '}';
       }
  
       public Integer getId() {
           return id;
       }
  
       public void setId(Integer id) {
           this.id = id;
       }
  
       public String getUsername() {
           return username;
       }
  
       public void setUsername(String username) {
           this.username = username;
       }
  
       public Date getBirthday() {
           return birthday;
       }
  
       public void setBirthday(Date birthday) {
           this.birthday = birthday;
       }
  
       public String getSex() {
           return sex;
       }
  
       public void setSex(String sex) {
           this.sex = sex;
       }
  
       public String getAddress() {
           return address;
       }
  
       public void setAddress(String address) {
           this.address = address;
       }
   }

  Role.java:

   package zh.test.domain;
  
   import java.io.Serializable;
   import java.util.List;
  
   public class Role implements Serializable {
       private  Integer id;
       private String role_name;
       private String role_desc;
       //一个角色可以对应多个人员
       private List<NBAPlaers> nbaers;
  
       public Integer getId() {
           return id;
       }
  
       public void setId(Integer id) {
           this.id = id;
       }
  
       public String getRole_name() {
           return role_name;
       }
  
       public void setRole_name(String role_name) {
           this.role_name = role_name;
       }
  
       public String getRole_desc() {
           return role_desc;
       }
  
       public void setRole_desc(String role_desc) {
           this.role_desc = role_desc;
       }
  
       public List<NBAPlaers> getNbaers() {
           return nbaers;
       }
  
       public void setNbaers(List<NBAPlaers> nbaers) {
           this.nbaers = nbaers;
       }
  
       @Override
       public String toString() {
           return "Role{" +
                   "id=" + id +
                   ", role_name='" + role_name + '\'' +
                   ", role_desc='" + role_desc + '\'' +
                   ", nbaers=" + nbaers +
                   '}';
       }
   }

• 编写相对应的接口，在接口中写对应的方法

　　　　UserMapper:

 package zh.test.mapper;

 import zh.test.domain.NBAPlaers;

 import java.util.List;

 /*
 用户映射接口
  */
 public interface UserMapper {
     //根据条件查询
     public NBAPlaers findById(int id);
     //多条件语句拼接查询
     public List<NBAPlaers> findByIds(NBAPlaers nbaPlaers);
     //使用foreach循环
     public List<NBAPlaers> findByeach(NBAPlaers nbaPlaers);
     //一对多的查询方式
     public List<NBAPlaers> findMany();
 }

　　AccountMapper:

 package zh.test.mapper;

 import zh.test.domain.Account;

 import java.util.List;

 public interface AccountMapper {
 //    多对一的两张表的数据查询
     public List<Account> findAll();

 }

　　RoleMapper:

 package zh.test.mapper;

 import zh.test.domain.Role;

 import java.util.List;

 public interface RoleMapper {
     public List<Role> findAll();
 }

• 　　在mappers的文件夹下面分别写一下几个文件。（三个文件会在SqlMapConfig.xml的文件引入一下的几个配置文件）

　　Usermapper.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!--约束   dtd约束-->
 <!DOCTYPE mapper
         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <!--
     namespace：用来区分mapper接口的，一般写mapper的全路径
 -->

 <mapper namespace="zh.test.mapper.UserMapper">

     <!--根据条件查询-->
     <!--
     id:findById 方法的名称
     parameterType：方法参数的类型
     resultType：方法返回值的类型

     ?   不能使用？作为占位符，使用#{} 或${}来编写，推荐使用#{}
     区别：1、#{}.
     2、${}
     以上两种，当方法的参数为【引用类型】的时候，两种都可以使用，没有区别
     当方法的参数为【普通数据类型（int double  ）】推荐使用#{此处的方法的名字可以随意命名},但是${此处的方法的名字的参数必须与写value}
     -->
     <select id="findById" parameterType="java.lang.Integer" resultType="zh.test.domain.NBAPlaers">
         select * from  NBAPlaers where  id=#{id}
     </select>
     <!--
     拼接sql语句
     根据条件判断是否要添加后面的条件
     -->
     <select id="findByIds" parameterType="nbaers" resultType="nbaers">
         select  * from  NBAPlaers
                        <where>
     <if test="username !=null and username !=''">
         and username like #{username}
     </if>
                        </where>
     </select>
     <!--抽取公共的部分-->
     <select id="findWhere">
         select * from NBAPlaers
     </select>
     <!--使用foreach循环-->
     <select id="findByeach" parameterType="nbaers" resultType="nbaers">
         select  * from  NBAPlaers
         <where>
 -- collection:要遍历的集合
 -- open="开始" close="关闭的" separator="分割" item="遍历后的变量" index="下标值"
             <foreach collection="ids" open="id = " separator="or id = " item="i">
                 #{i}
             </foreach>
         </where>
     </select>
     <!--通过两张表之间的关联，查询一对多的查询方式

     -->
     <select id="findMany" resultMap="Unfind">
         SELECT n.*,n.id nid,a.id aid ,a.money FROM account a,NBAPlaers n where a.uid=n.id
     </select>
     <resultMap id="Unfind" type="nbaers">
         <result property="id" column="id"/>
         <result property="username" column="username"/>
         <result property="sex" column="sex"/>
         <collection property="accounts" ofType="Account">
             <result property="id" column="aid"/>
             <result property="money" column="money"/>
         </collection>
     </resultMap>
 </mapper>

Accountmapper.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!--约束   dtd约束-->
 <!DOCTYPE mapper
         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <!--
     namespace：用来区分mapper接口的，一般写mapper的全路径
 -->

 <mapper namespace="zh.test.mapper.UserMapper">

     <!--根据条件查询-->
     <!--
     id:findById 方法的名称
     parameterType：方法参数的类型
     resultType：方法返回值的类型

     ?   不能使用？作为占位符，使用#{} 或${}来编写，推荐使用#{}
     区别：1、#{}.
     2、${}
     以上两种，当方法的参数为【引用类型】的时候，两种都可以使用，没有区别
     当方法的参数为【普通数据类型（int double  ）】推荐使用#{此处的方法的名字可以随意命名},但是${此处的方法的名字的参数必须与写value}
     -->
     <select id="findById" parameterType="java.lang.Integer" resultType="zh.test.domain.NBAPlaers">
         select * from  NBAPlaers where  id=#{id}
     </select>
     <!--
     拼接sql语句
     根据条件判断是否要添加后面的条件
     -->
     <select id="findByIds" parameterType="nbaers" resultType="nbaers">
         select  * from  NBAPlaers
                        <where>
     <if test="username !=null and username !=''">
         and username like #{username}
     </if>
                        </where>
     </select>
     <!--抽取公共的部分-->
     <select id="findWhere">
         select * from NBAPlaers
     </select>
     <!--使用foreach循环-->
     <select id="findByeach" parameterType="nbaers" resultType="nbaers">
         select  * from  NBAPlaers
         <where>
 -- collection:要遍历的集合
 -- open="开始" close="关闭的" separator="分割" item="遍历后的变量" index="下标值"
             <foreach collection="ids" open="id = " separator="or id = " item="i">
                 #{i}
             </foreach>
         </where>
     </select>
     <!--通过两张表之间的关联，查询一对多的查询方式

     -->
     <select id="findMany" resultMap="Unfind">
         SELECT n.*,n.id nid,a.id aid ,a.money FROM account a,NBAPlaers n where a.uid=n.id
     </select>
     <resultMap id="Unfind" type="nbaers">
         <result property="id" column="id"/>
         <result property="username" column="username"/>
         <result property="sex" column="sex"/>
         <collection property="accounts" ofType="Account">
             <result property="id" column="aid"/>
             <result property="money" column="money"/>
         </collection>
     </resultMap>
 </mapper>

Rolemapper.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!--约束   dtd约束-->
 <!DOCTYPE mapper
         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <!--
     namespace：用来区分mapper接口的，一般写mapper的全路径
 -->
 <!--
     多对多的查询，拆分为一对多
 -->
 <mapper namespace="zh.test.mapper.RoleMapper">
     <select id="findAll" resultMap="roleMapper">
         SELECT r.*,n.username FROM NBAPlaers n,role r,nba_role nr WHERE nr.uid=n.id and r.id=nr.rid;
     </select>
      <resultMap id="roleMapper" type="role">
          <result property="id" column="id"/>
          <result property="role_name" column="role_name"/>
          <result property="role_desc" column="role_desc"/>
          <collection property="nbaers" ofType="nbaers">
              <result property="username" column="username"/>
          </collection>
      </resultMap>
 </mapper>

• 最后对不同的模块不同的功能做测试，其中在最前面的项目结构截图test下面的Demo、Demo2、Demo3分别对应模块UserMapper、AccountMapper、RoleMapper

　　　　Demo：

 package test;

 import org.apache.ibatis.io.Resources;
 import org.apache.ibatis.session.SqlSession;
 import org.apache.ibatis.session.SqlSessionFactory;
 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 import org.junit.Test;
 import zh.test.domain.NBAPlaers;
 import zh.test.mapper.UserMapper;

 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;

 public class Demo {
 //根据id查询数据
     @Test
     public void findById() throws IOException {
         InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
         SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsStream);
         SqlSession sqlSession = build.openSession();
         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
         NBAPlaers nbaPlaer = mapper.findById(2);
         System.out.println(nbaPlaer);
         sqlSession.close();
         resourceAsStream.close();
 //       这里代码看不懂可以查看mybatis01的代码
     }

 //    根据多条件的方式查询，在UserMapper.xml 文件中使用where和if的标签拼接查询方式
     @Test
     public void findByIds() throws IOException {
         InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
         SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsStream);
         SqlSession sqlSession = build.openSession();
         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
         NBAPlaers nbaPlaers=new NBAPlaers();
         nbaPlaers.setUsername("%o%");
         List<NBAPlaers> byIds = mapper.findByIds(nbaPlaers);
         for(NBAPlaers n:byIds)
         {
             System.out.println(n);
         }
         sqlSession.close();
         resourceAsStream.close();
     }
 //    使用foreach循环，在UserMapper.xml 文件中使用foreach的标签循环
     @Test
     public void findByforeachIds() throws IOException {
         InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
         SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsStream);
         SqlSession sqlSession = build.openSession();
         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
         NBAPlaers nbaPlaers=new NBAPlaers();
         List<Integer> list=new ArrayList<Integer>();
         list.add(1);
         list.add(2);
         list.add(3);
         nbaPlaers.setIds(list);
         List<NBAPlaers> byIds = mapper.findByeach(nbaPlaers);
         for(NBAPlaers n:byIds)
         {
             System.out.println(n);
         }
         sqlSession.close();
         resourceAsStream.close();
     }
 //    一对多通过两张表之间的关联查询数据
     @Test
     public void findTwoTable() throws IOException {
         InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
         SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsStream);
         SqlSession sqlSession = build.openSession();
         UserMapper mapper = sqlSession.getMapper(UserMapper.class);
         List<NBAPlaers> byIds = mapper.findMany();
         for(NBAPlaers n:byIds)
         {
             System.out.println(n);
         }
         sqlSession.close();
         resourceAsStream.close();
     }
 }

Demo2:

 package test;

 import org.apache.ibatis.io.Resources;
 import org.apache.ibatis.session.SqlSession;
 import org.apache.ibatis.session.SqlSessionFactory;
 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 import org.junit.Test;
 import zh.test.domain.Account;
 import zh.test.domain.NBAPlaers;
 import zh.test.mapper.AccountMapper;
 import zh.test.mapper.UserMapper;

 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;

 public class Demo2 {

 //    多对一的查询方式
     @Test
     public void findByAll() throws IOException {
         InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
         SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsStream);
         SqlSession sqlSession = build.openSession();
         AccountMapper mapper = sqlSession.getMapper(AccountMapper.class);
         List<Account> all = mapper.findAll();
         for (Account account : all) {
             System.out.println(account);
         }
         sqlSession.close();
         resourceAsStream.close();
     }
 }

Demo3:

 package test;

 import org.apache.ibatis.io.Resources;
 import org.apache.ibatis.session.SqlSession;
 import org.apache.ibatis.session.SqlSessionFactory;
 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 import org.junit.Test;
 import zh.test.domain.Role;
 import zh.test.mapper.RoleMapper;

 import java.io.IOException;
 import java.io.InputStream;
 import java.util.List;

 public class Demo3 {
 //
     @Test
     public void findAll() throws IOException {
         InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
         SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsStream);
         SqlSession sqlSession = build.openSession();
         RoleMapper mapper = sqlSession.getMapper(RoleMapper.class);
         List<zh.test.domain.Role> all = mapper.findAll();
         for (Role role : all) {
             System.out.println(role);
         }
         sqlSession.close();
         resourceAsStream.close();
     }
 }

　　　分享之路，欢迎交流。。。