蟠桃种子播种方法好学吗?

小说:蟠桃种子播种方法好学吗?作者:纯辛更新时间:2019-04-23字数:13084

于是他也不答话,一声令下。只见二十八星宿围成个大阵,将上下左右去路封死,当中只余托塔天王与哪吒三太子,四大金刚手持金刚杵,居于四角虎视眈眈。

云南可以种植黄玉兰吗?

他已经看出林珂是真的喜欢叶扬,否则也不会做出求婚之事,现在他要是把那种事说出来,林珂还不疯了啊。
“师太你也是老江湖了,应该看出你的弟子差不多是对吴应熊芳心暗许了,而他又救过你的弟子,那么就直接看看他内心如何吧。”艾斯德斯说道:“如果他真的和你的弟子说的那样是我说谎,胡编乱造的话,那么今天我就不杀她,如果是假的,我请师太将他交给我吧。”

所以冷电银枪的挣扎不过是白费力气罢了,刘皓右手一握,滔滔江河般的力量倾泻而出,冷电银枪怎么挣扎都毫无作用,在刘皓的手中无法动弹,这让一边的岳银瓶心里更加敬佩刘皓了,冷电银枪她可是很清楚,傲娇的很。

Mybatis框架

一、什么是Mybatis  

  MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis 。2013年11月迁移到Github。iBATIS一词来源于“internet”和“abatis”的组合,是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAOs)。
  MyBatis 是一款优秀的持久层框架,它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息,将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。
                                                                                      ---------------百度百科

二、Mybatis与Hibernate区别

  两个都是持久层框架,操作数据库,但是两者还是有区别的 

  hibernate:它是一个标准的orm框架,比较重量级,学习成本高.
  优点:高度封装,使用起来不用写sql,开发的时候,会减低开发周期.
  缺点:sql语句无法优化
  应用场景:oa(办公自动化系统), erp(企业的流程系统)等,还有一些政府项目,
  总的来说,在用于量不大,并发量小的时候使用.
  mybatis:它不是一个orm框架, 它是对jdbc的轻量级封装, 学习成本低,比较简单
  优点:学习成本低, sql语句可以优化, 执行效率高,速度快
  缺点:编码量较大,会拖慢开发周期
  应用场景: 互联网项目,比如电商,P2p等
  总的来说是用户量较大,并发高的项目。

三、体验原始的jdbc开发

  1、导入jar包

   此时操作数据库,需要引入数据库驱动,这里我使用的是mysql驱动

  

  2、编写jdbc程序

  

public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        
        try {
            //加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");
            
            //通过驱动管理类获取数据库链接
            connection =  DriverManager.getConnection("jdbc:mysql://192.168.174.130:3306/SSM", "root", "root");
            //定义sql语句 ?表示占位符
        String sql = "select * from myUser where username = ?";
            //获取预处理statement
            preparedStatement = connection.prepareStatement(sql);
            //设置参数,第一个参数为sql语句中参数的序号(从1开始),第二个参数为设置的参数值
            preparedStatement.setString(1, "王五");
            //向数据库发出sql执行查询,查询出结果集
            resultSet =  preparedStatement.executeQuery();
            //遍历查询结果集
            while(resultSet.next()){
                System.out.println(resultSet.getString("id")+"  "+resultSet.getString("username"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            //释放资源
            if(resultSet!=null){
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(preparedStatement!=null){
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

        }

    }

  缺点:频繁创建释放资源降低性能;代码耦合性强,不易维护;传参与所获结果集编码不够灵活(存在硬编码)

  综上:mybatis解决了以上问题

  1、SqlMapConfig.xml中配置数据链接池,使用连接池管理数据库链接,大大减少了不断创建释放资源。

  2、Sql语句配置在XXXXmapper.xml文件中与java代码分离。

  3、Mybatis自动将java对象映射至sql语句,通过statement中的parameterType定义输入参数的类型。解决了条件查询中笨重问题

 

 

四、快速部署环境

  1、下载jar包

  mybatis官网:   http://www.mybatis.org/mybatis-3/

  jar包下载地址:  https://github.com/mybatis/mybatis-3/releases

  2、新建工程,导入相关jar包

  

  3、在工程(不是src)下建立一个源码包,用于存放配置文件

  4、在源码中配置一个日志文件,用于打印日志

# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

  5、配置核心配置文件

  配置文件中主要是配置连接数据库和事务管理的内容,文件名可以自定义,默认SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration 
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"https://www.mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 和spring整合后 environments配置将废除-->
    <environments default="development">
        <environment id="development">
        <!-- 使用jdbc事务管理-->
            <transactionManager type="JDBC" />
        <!-- 数据库连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://192.168.174.130:3306/SSM" />
                <!--注意:这里必须是username,一定要规范-->
                <property name="username" value="root" /> 
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>
</configuration>

  6、配置sql映射文件,文件名自定义,这里默认为User.xml,

  与hibernate想区别的是:hibernate是通过操作映射文件对象来操作数据库,与sql无太大关系;mybatis的映射文件是用来写sql语句的

  注意:此文件放在源码包下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://www.mybatis.org/dtd/mybatis-3.0-mapper.dtd">
<!-- namespace命名空间,做sql隔离,防止命名重复 -->
<mapper namespace="test">
   
</mapper>

  7、在核心配置文件中引入映射文件

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

  此时环境差不多就部署好了

五、需求开发

  1、根据id查询一个客户

  1)建立客户表

  2)定义pojo类

package com.clj.pojo;

import java.util.Date;
import java.util.List;

public class User {
    private int id;
    private String username;// 用户姓名
    private String sex;// 性别
    private Date birthday;// 生日
    private String address;// 地址
    private List<Orders> ordersList;
    
    public List<Orders> getOrdersList() {
        return ordersList;
    }
    public void setOrdersList(List<Orders> ordersList) {
        this.ordersList = ordersList;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", sex=" + sex
                + ", birthday=" + birthday + ", address=" + address + "]";
    }
    
}

  3)在User.xml文件中配置sql语句

  注意:当传入参数类型时原始型时,占位符中的括号中的值可以随意设置,但最好可读性较强(占位符能自动进行java类型和jdbc类型转换,可以有效防止sql注入。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://www.mybatis.org/dtd/mybatis-3.0-mapper.dtd">
<!-- namespace命名空间,做sql隔离 -->
<mapper namespace="test">
    <!-- 
        id:sql语句唯一标识
        parameterType:指定传入参数类型(对应javaBean类型,写原始型会自动包装为包装类)
        resultType:返回结果类型
        #{}:占位符号,起到占位作用,如果传入的是原始型,那么括号中的变量名称可以随意定义
     -->
    <select id="findUserById" parameterType="int" resultType="com.clj.pojo.User">
        select * from user where id=#{id}
    </select>
</mapper>

  3)测试

  值得注意的是,这里调用sql的写法

  @Test
    public void testFindUserById() throws Exception{
        String resource="SqlMapConfig.xml";
        InputStream inputStream=Resources.getResourceAsStream(resource);
        //创建工厂
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputStream);
        //通过工厂创建会话
        SqlSession openSession=factory.openSession();
        //第一个参数:所调用的sql语句:namespace+‘.’+SqlID
        //第二个参数:传入的参数
        User user=openSession.selectOne("test.findUserById",1);
        System.out.println(user);
        openSession.close();
    }

  这里调用的是selectOne方法,旨在查询一条指定的数据,如果用它查询多条数据,会报异常(查询多条要用selectList)

  

 

  2、根据用户名查询客户

  1)在User.xml文件中配置sql语句

  注意:当传入的参数是非引用型时,拼接符要用"value"(拼接符不进行jdbc类型转换, ${}可以接收简单类型值或pojo属性值,如果parameterType传输单个简单类型值,${}括号中只能是value)

     这里返回值为List集合,配置为该集合的泛型

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://www.mybatis.org/dtd/mybatis-3.0-mapper.dtd">
<!-- namespace命名空间,做sql隔离 -->
<mapper namespace="test">
    <!-- 如果返回结果为集合,可以调用selectList方法。这个方法返回结果就有个集合 ,
    所以映射文件应该配置成集合的泛型
    ${}拼接符:字符串原样拼接,如果传入的参数是基本类型,括号中的值必须为“value”
    注意:拼接符有sql注入的风险,所以慎用(=号用占位符,like用拼接符)-->
    <select id="findUserByUserName" parameterType="java.lang.String" resultType="com.clj.pojo.User">
        <!--select * from user where username like #{name}  -->
        select * from user where username like "%${value}%"
    </select>
</mapper>

  2)测试

  @Test
    public void testFindUSerByUserName() throws Exception{
        String resource="SqlMapConfig.xml";
        InputStream inputstream=Resources.getResourceAsStream(resource);
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputstream);
        SqlSession openSession=factory.openSession();
        //List<User> list=openSession.selectList("test.findUserByUserName","%王%");
        List<User> list=openSession.selectList("test.findUserByUserName","王");
        System.out.println(list);
        openSession.close();
    }

  3、插入数据

  1)配置sql

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://www.mybatis.org/dtd/mybatis-3.0-mapper.dtd">
<!-- namespace命名空间,做sql隔离 -->
<mapper namespace="test">
    <!-- 
        #{}:如果传入的是pojo类型,那么#{}中变量的名称必须是pojo中对应的属性
        如果要返回数据库自增主键,可以使用select LAST_INSERT_ID()
     -->
    <insert id="insertUser" parameterType="com.clj.pojo.User">
    <!-- 执行 LAST_INSERT_ID,返回自增的主键
        keyProperty:将返回的主键放入传入参数的ID中保存
        order:相当于insert语句的执行顺序,在insert前执行时before,之后是after
        resultType:keyProperty中属性的类型,
        -->
        <selectKey keyProperty="id" order="AFTER" resultType="int">
            select LAST_INSERT_ID()
        </selectKey>
        insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
    </insert>
</mapper>

  注意:这里添加selectKey实现将主键返回,因为是先插入数据,才能获得主键,所以其属性值order="AFTER"

  如果是uuid(随机字符串),属性值order="Before"

<insert  id="insertUser" parameterType="cn.itcast.mybatis.po.User">
<selectKey resultType="java.lang.String" order="BEFORE" 
keyProperty="id">
select uuid()
</selectKey>
insert into user(id,username,birthday,sex,address) 
         values(#{id},#{username},#{birthday},#{sex},#{address})
</insert>

 

  2) 测试

  @Test
    public void testInsertUser() throws Exception{
        String resource="SqlMapConfig.xml";
        InputStream inputstream=Resources.getResourceAsStream(resource);
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputstream);
        SqlSession openSession=factory.openSession();
        User user=new User();
        user.setUsername("赵四");
        user.setBirthday(new Date());
        user.setSex("1");
        user.setAddress("长沙市");
        System.out.println("======"+user.getId());
        openSession.insert("test.insertUser",user);
        //提交事务(mybatis会自动提交事务,但是不知道何时手动提交事务)
        openSession.commit();
        System.out.println("========"+user.getId());
        openSession.close();
    }

  4、删除更新数据

  1)配置sql语句

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://www.mybatis.org/dtd/mybatis-3.0-mapper.dtd">
<!-- namespace命名空间,做sql隔离 -->
<mapper namespace="test">
    <delete id="delUserById" parameterType="int">
        delete from user where id=#{id}
    </delete>
    <update id="updateUserById" parameterType="com.clj.pojo.User">
        update user set username=#{username} where id=#{id}
    </update>
</mapper>

  2)测试

@Test
    public void testDelUserById() throws Exception{
        String resource="SqlMapConfig.xml";
        InputStream inputstream=Resources.getResourceAsStream(resource);
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputstream);
        SqlSession openSession=factory.openSession();
        openSession.delete("test.delUserById",29);
        openSession.commit();
        openSession.close();
    }
    @Test
    public void testUpdateUserById()throws Exception{
        String resource="SqlMapConfig.xml";
        InputStream inputstream=Resources.getResourceAsStream(resource);
        SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputstream);
        SqlSession openSession=factory.openSession();
        User user=new User();
        user.setId(28);
        user.setUsername("佳先森");
        openSession.update("test.updateUserById",user);
        openSession.commit();
        openSession.close();
    }

   扩展:将连接数据库中的属性封装到数据库配置文件中

  1、在源码包中配置db.properties

jdbc.driver=com.mysql.jdbc.Driver	
jdbc.url=jdbc:mysql://192.168.174.130:3306/SSM
jdbc.username=root
jdbc.password=root

  2、修改核心配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration 
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"https://www.mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 引入链接数据库配置文件 -->
    <properties resource="db.properties"/>
    <!-- 和spring整合后 environments配置将废除-->
    <environments default="development">
        <environment id="development">
        <!-- 使用jdbc事务管理-->
            <transactionManager type="JDBC" />
        <!-- 数据库连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}" />
                <property name="url" value="${jdbc.url}" />
                <!--注意:这里必须是username,一定要规范-->
                <property name="username" value="${jdbc.username}" /> 
                <property name="password" value="${jdbc.password}" />
            </dataSource>
        </environment>
    </environments>
    <mappers><mapper resource="User.xml"/>
    </mappers>
</configuration>

六、mybatis支持别名

  在核心配置文件中第一个类的别名,后面可以直接引用别名,无需配置全路径

<typeAliases>
    <!-- 定义单个pojo类别名
        type:类的全路径名称
        alias:别名
     -->
        <typeAlias type="com.clj.pojo.User" alias="user"/>
    <!-- 使用包扫描的方式批量定义别名,定义后别名等于类名
    ,不区分大小写 ,但最好按照驼峰命名法书写-->
    <package name="com.clj.pojo"/>
    </typeAliases>

七、mybatis引入映射文件写法

  有两种写法:一种是单个引入,另一种是包扫描的方式

    <mappers>
        <!-- 两种引入方式 
        方式一:单个引入
        
        <mapper resource="User.xml"/>-->
        <!-- 使用class属性引入接口的全路径名称:
            使用规则:1.接口名称和映射文件名称除扩展名之外要完全相同
                    2.接口和映射文件要放在同一个目录下
         
        <mapper class="com.clj.UserMapper.UserMapper"/>-->
        <!-- 方式二:使用包扫描的方式批量引入Mapper
        使用包扫描规则和上个一样
         -->
         <package name="com.clj.UserMapper"/>
    </mappers>

八、MyBatis之Dao层的开发方式

  MyBatis之Dao层的开发方式有两种:原始Dao开发和Mapper接口开发

  1、Dao开发方式一:原始Dao开发

    1)配置user.xml中的sql语句

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://www.mybatis.org/dtd/mybatis-3.0-mapper.dtd">
<!-- namespace命名空间,做sql隔离 -->
<mapper namespace="test">
  <select id="findUserById" parameterType="int" resultType="com.clj.pojo.User">
        select * from user where id=#{id}
    </select>
  <select id="findUserByUserName" parameterType="java.lang.String" resultType="com.clj.pojo.User">

    select * from user where username like "%${value}%"
   </select>

</mapper>

    2)定义接口和实现类

package com.clj.dao;

import java.util.List;

import com.clj.pojo.User;

public interface UserDao {
    public User findUserById(Integer id);
    public List<User> findUserByUserName(String username);
}
package com.clj.dao;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import com.clj.pojo.User;

public class UserDaoImpl implements UserDao{
    private SqlSessionFactory sqlSessionFactory;
    //通过构造方法注入
    public UserDaoImpl(SqlSessionFactory sqlSessionFactory) {
        super();
        this.sqlSessionFactory = sqlSessionFactory;
    }
    @Override
    public User findUserById(Integer id) {
        //SqlSession是线程不安全的,所以他的最佳使用的范围在方法体内
        SqlSession opeanSession=sqlSessionFactory.openSession();
        User user=opeanSession.selectOne("test.findUserById",id);
        return user;
    }
    @Override
    public List<User> findUserByUserName(String username) {
        SqlSession opeanSession=sqlSessionFactory.openSession();
        List<User> list=opeanSession.selectList("test.findUserByUserName",username);
        return list;
    }
    
}

  3)在核心配置文件SqlMapConfig.xml中引入user.xml

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

  4)定义测试类进行测试

package com.clj.Test;

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

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.Before;
import org.junit.Test;

import com.clj.dao.UserDao;
import com.clj.dao.UserDaoImpl;
import com.clj.pojo.User;

public class UserDaoTest {
    private SqlSessionFactory factory;
    
    //@Before作用在测试方法之前执行这个方法
    @Before
    public void setUp() throws Exception{
        String resource="SqlMapConfig.xml";
        InputStream inputstream=Resources.getResourceAsStream(resource);
        factory=new SqlSessionFactoryBuilder().build(inputstream);
        SqlSession openSession=factory.openSession();
    }
    @Test
    public void testFindUserById() throws Exception{
        //将初始化的工厂注入到实现类中
        UserDao userDao=new UserDaoImpl(factory);
        User user=userDao.findUserById(1);
        System.out.println(user);
    }
    @Test
    public void testFindUserByUserName() throws Exception{
        UserDao userDao=new UserDaoImpl(factory);
        List<User> list=userDao.findUserByUserName("王");
        System.out.println(list);
    }
}    

  总结:原始Dao还是存在一些不好的因素:1.代码有重复 2.sqlSession调用sql时需要指定id值,存在硬编码

  2、Dao开发方式二:Mapper动态代理的方式

  Mapper动态代理的方式需要严格遵守一些规范

  需求一:通过主键查找用户;通过用户名查找用户;插入用户数据

 

  1)定义接口

package com.clj.UserMapper;

import java.util.List;

import com.clj.pojo.CustomerOrders;
import com.clj.pojo.Orders;
import com.clj.pojo.QueryVo;
import com.clj.pojo.User;

//与之关乎的配置文件要在同一个目录包下
public interface UserMapper {
    public User findUserById(Integer id);
    //注意:这里是模糊查询,配置文件虽然写的是User,实际返回的是List集合
    //动态代理形式中,如果返回结果集List,那么mybatis会在生成实现类的时候会自动调用selectList方法
    public List<User> findUserByUserName(String userName);
    public  void insertUser(User user);
    
}

 

  2)定义其映射文件,最好是在同目录下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://www.mybatis.org/dtd/mybatis-3.0-mapper.dtd">
<!--mapper接口代理实现编写轨则
    1.映射文件中namespace要等于接口的全路径名
    2.映射文件中sql语句id要等于接口的方法名称
    3.映射文件中传入参数类型要等于接口方法的传入参数类型
    4.映射文件中返回结果集类型等于接口方法的返回值类型
 -->
<mapper namespace="com.clj.UserMapper.UserMapper">
    <select id="findUserById" parameterType="int" resultType="com.clj.pojo.User">
        select * from user where id=#{id}
    </select>
    <select id="findUserByUserName" parameterType="java.lang.String" resultType="com.clj.pojo.User">
        <!--select * from user where username like #{name}  -->
        select * from user where username like "%${value}%"
    </select>
    <!-- 这里返回值使用的别名 -->
    <insert id="insertUser" parameterType="user">
        <selectKey keyProperty="id" order="AFTER" resultType="int">
            select LAST_INSERT_ID()
        </selectKey>
        insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
    </insert>
</mapper>

 

   两文件的目录关系

   

 

  3)在核心配置文件中引入Mapper的配置文件

<mappers>
        <!-- 两种引入方式 
        方式一:单个引入
        
        <mapper resource="User.xml"/>-->
        <!-- 方式二:使用包扫描的方式批量引入Mapper
        使用包扫描规则和上个一样
         -->
         <package name="com.clj.UserMapper"/>
    </mappers>

  ·4)测试类

  

package com.clj.Test;

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

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.Before;
import org.junit.Test;

import com.clj.UserMapper.UserMapper;
import com.clj.pojo.CustomerOrders;
import com.clj.pojo.Orders;
import com.clj.pojo.QueryVo;
import com.clj.pojo.User;

public class UserMapperTest {
private static SqlSessionFactory factory;
    
    //@Before作用在测试方法之前执行这个方法
    @Before
    public void setUp() throws Exception{
        String resource="SqlMapConfig.xml";
        InputStream inputstream=Resources.getResourceAsStream(resource);
        factory=new SqlSessionFactoryBuilder().build(inputstream);
        SqlSession openSession=factory.openSession();
    }
    @Test
    public void testFindUserById() throws Exception{
        SqlSession openSession=factory.openSession();
        //通过getMapper方法实列化接口
        UserMapper mapper=openSession.getMapper(UserMapper.class);
        User user=mapper.findUserById(1);
        System.out.println(user);
    }
 
}

   另外:删除用户和更新用户sql配置文件方式为,具体步骤如上

    <delete id="delUserById" parameterType="int">
        delete from user where id=#{id}
    </delete>
    <update id="updateUserById" parameterType="com.clj.pojo.User">
        update user set username=#{username} where id=#{id}
    </update>

  需求二:根据用户名查询,利用高级查询Vo类

  1)创建Vo类封装用户属性,并提供set/get方法

package com.clj.pojo;

import java.util.List;

//用于高级查询
public class QueryVo {
    private User user;
    private List<Integer> ids;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public List<Integer> getIds() {
        return ids;
    }

    public void setIds(List<Integer> ids) {
        this.ids = ids;
    } 
}

  2)在UserMapper.xml文件中配置查询语句

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://www.mybatis.org/dtd/mybatis-3.0-mapper.dtd">
<!--mapper接口代理实现编写轨则
    1.映射文件中namespace要等于接口的全路径名
    2.映射文件中sql语句id要等于接口的方法名称
    3.映射文件中传入参数类型要等于接口方法的传入参数类型
    4.映射文件中返回结果集类型等于接口方法的返回值类型
 -->
<mapper namespace="com.clj.UserMapper.UserMapper">
    <select id="findUserbyVo" parameterType="com.clj.pojo.QueryVo" resultType="com.clj.pojo.User">
        select * from user where username like "%${user.username}%" and sex=#{user.sex}
    </select>
</mapper>

  3)定义接口

public List<User> findUserbyVo(QueryVo vo);

  4)测试类

public class UserMapperTest {
private static SqlSessionFactory factory;
    
    //@Before作用在测试方法之前执行这个方法
    @Before
    public void setUp() throws Exception{
        String resource="SqlMapConfig.xml";
        InputStream inputstream=Resources.getResourceAsStream(resource);
        factory=new SqlSessionFactoryBuilder().build(inputstream);
        SqlSession openSession=factory.openSession();
    }
  @Test
    public void testFindUserByVo() throws Exception{
        SqlSession openSession=factory.openSession();
        //通过getMapper方法实列化接口
        UserMapper mapper=openSession.getMapper(UserMapper.class);
        QueryVo vo=new QueryVo();
        User user=new User();
        user.setUsername("张");
        user.setSex("1");
        List<User> list=mapper.findUserbyVo(vo);
        System.out.println(list);
        openSession.close();
    }
}

  需求三:查询数据总数,利用count(*)

  1) 配置sql

<!-- 只有返回结果为一行一列的时候,那么返回值类型时可以指定类型为基本类型 -->
    <select id="findUserCount" resultType="int">
        select count(*) from user
    </select>

  2) 配置接口

    public Integer findUserCount();

  3)测试

@Test
    public void testFindUserCount()throws Exception{
        SqlSession opneSession=factory.openSession();
        //通过getMapper方法实例化接口
        UserMapper mapper=opneSession.getMapper(UserMapper.class);
        Integer count=mapper.findUserCount();
        System.out.println("===="+count);
    }

  需求四:动态增加查询条件

  1)配置sql

  方式一:局部配置

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://www.mybatis.org/dtd/mybatis-3.0-mapper.dtd">
<!--mapper接口代理实现编写轨则
    1.映射文件中namespace要等于接口的全路径名
    2.映射文件中sql语句id要等于接口的方法名称
    3.映射文件中传入参数类型要等于接口方法的传入参数类型
    4.映射文件中返回结果集类型等于接口方法的返回值类型
 -->
<mapper namespace="com.clj.UserMapper.UserMapper">
<select id="findUserByUserNameAndSex" parameterType="com.clj.pojo.User" resultType="com.clj.pojo.User">
        select * from  user
        <!-- where标签作用:
            会自动向sql语句中添加where关键字
            会去掉第一个条件的and关键字 -->
        <where>
        <if test="username!=null and username !=""">
            and username like "%${username}%"
        </if>
        <if test="sex !=null and sex!=""">
            and sex=#{sex}
        </if>
        </where>
    </select>
</mapper>

  方式二:全局配置

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://www.mybatis.org/dtd/mybatis-3.0-mapper.dtd">
<!--mapper接口代理实现编写轨则
    1.映射文件中namespace要等于接口的全路径名
    2.映射文件中sql语句id要等于接口的方法名称
    3.映射文件中传入参数类型要等于接口方法的传入参数类型
    4.映射文件中返回结果集类型等于接口方法的返回值类型
 -->
<mapper namespace="com.clj.UserMapper.UserMapper">
    <!-- 封装sql条件,封装后可以重用 
        id:此sql的唯一标识符
    -->
    <sql id="user_where">
        <where>
        <if test="username!=null and username !=""">
            and username like "%${username}%"
        </if>
        <if test="sex !=null and sex!=""">
            and sex=#{sex}
        </if>
        </where>
        
    </sql>    
<select id="findUserByUserNameAndSex" parameterType="com.clj.pojo.User" resultType="com.clj.pojo.User">
        select * from  user
        <!-- where标签作用:
            会自动向sql语句中添加where关键字
            会去掉第一个条件的and关键字 
        <where>
        <if test="username!=null and username !=""">
            and username like "%${username}%"
        </if>
        <if test="sex !=null and sex!=""">
            and sex=#{sex}
        </if>
        </where>-->
        <!-- 调用全局条件 -->
        <include refid="user_where"/>
    </select>
</mapper>

  2)接口

public List<User> findUserByUserNameAndSex(User user);

  3)测试

@Test
    public void testFindUserbyUserNameAndSex() throws Exception{
        SqlSession opneSession=factory.openSession();
        UserMapper mapper=opneSession.getMapper(UserMapper.class);
        User user=new User();
        user.setUsername("张");
        user.setSex("1");
        List<User> list=mapper.findUserByUserNameAndSex(user);
        System.out.println(list);
    }

  需求五:查询主键在某个范围内(动态添加条件查询之foreach标签)

  1)sql配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://www.mybatis.org/dtd/mybatis-3.0-mapper.dtd">
<!--mapper接口代理实现编写轨则
    1.映射文件中namespace要等于接口的全路径名
    2.映射文件中sql语句id要等于接口的方法名称
    3.映射文件中传入参数类型要等于接口方法的传入参数类型
    4.映射文件中返回结果集类型等于接口方法的返回值类型
 -->
<mapper namespace="com.clj.UserMapper.UserMapper">
<select id="findUserByIds" parameterType="com.clj.pojo.QueryVo" resultType="com.clj.pojo.User">
        <!-- select * from user where id in (1,16,28,22) -->
            select * from user
        <where>
            <!-- 这里的id指定是vo中的集合属性 -->
            <if test="ids!=null">
                <!-- foreach:循环传入的集合参数
                    collection:传入的集合的变量名称
                    item:每次循环将循环的数据放入这个变量中
                    open:循环开始拼接的字符串
                    close:循环结束拼接的字符串
                    separator:循环中拼接的分隔符
                 -->
                <foreach collection="ids" item="id" open="id in (" close=")" separator=",">
                    #{id}
                </foreach>
            </if>
        </where>
    </select>
</mapper>

  2)接口

    public List<User> findUserByIds(QueryVo vo);

  3)测试

public class UserMapperTest {
private static SqlSessionFactory factory;
    
    //@Before作用在测试方法之前执行这个方法
    @Before
    public void setUp() throws Exception{
        String resource="SqlMapConfig.xml";
        InputStream inputstream=Resources.getResourceAsStream(resource);
        factory=new SqlSessionFactoryBuilder().build(inputstream);
        SqlSession openSession=factory.open

编辑:宗乙建

发布:2019-04-23 14:10:52

当前文章:http://scycxh.com/news/201904/14/content_34540.html

甘肃有荷花种植基地吗? 30公分高红叶小檗什么价格? 9月份能栽植水蜡吗? 美国红枫生长速度快吗? 重庆可以栽植剑麻吗? 市场最新报价,了解鸡血藤批发价,请来华东最大鸡血藤产区 红梅哪个品种珍贵? 橡树种子几月播种最好?

46026 94787 49205 63013 25323 83931 83392 36726 51407 96282 54613 20232 23961 52836 22865 54493 71075 81856 50662 26812

我要说两句: (0人参与)

发布