LayUI使用及Mybatis入门

LayUI

LayUI异步登录1.页面

<body>
<div id="container">
    <div></div>
    <div class="admin-login-background">
        <div class="admin-header">
            <span>layuimini</span>
        </div>
        <form id="form" class="layui-form">
            <div>
                <i class="layui-icon layui-icon-username admin-icon"></i>
                <input type="text" name="username" id="username" placeholder="请输入用户名" autocomplete="off" class="layui-input admin-input admin-input-username" value="admin">
            </div>
            <div>
                <i class="layui-icon layui-icon-password admin-icon"></i>
                <input type="password" name="password" id="password" placeholder="请输入密码" autocomplete="off" class="layui-input admin-input" value="123456">
            </div>
            <div>
                <input type="text" name="captcha" placeholder="请输入验证码" autocomplete="off" class="layui-input admin-input admin-input-verify" value="xszg">
                <img class="admin-captcha" width="90" height="30" src="../images/captcha.jpg">
            </div>
            <button   class="layui-btn admin-button" lay-submit="" lay-filter="login">登 陆</button>
        </form>
    </div>
</div>
<!--jquery的js文件-->
<script src="/LayUI_war_exploded/lib/jquery-3.4.1/jquery-3.4.1.min.js"></script>
<script src="/LayUI_war_exploded/lib/layui-v2.5.5/layui.js" charset="utf-8"></script>
<!--layUI--脚本--表单模块-->
<script>
    layui.use(['form'], function () {
        var form = layui.form,
            layer = layui.layer;

        // 登录过期的时候,跳出ifram框架
        if (top.location != self.location) top.location = self.location;

        // 进行登录操作
        //layUI表单提交操作
       form.on('submit(login)', function (data) {
            data = data.field; //将原生js对象转换成layUi里面的js对象
            //alert(data.username+"--"+data.password) ;
            if (data.username == '') {
                layer.msg('用户名不能为空');
                return false;
            }
            if (data.password == '') {
                layer.msg('密码不能为空');
                return false;
            }
            //忽略验证码
            if (data.captcha == '') {
                //layer.msg('验证码不能为空');
                return true;
            }

            //jquery的ajax
            $.ajax({
                url:"/LayUI_war_exploded/admin_login",
                type:"post",
                //发送json数据---JSON.stringfy(
                data: JSON.stringify(data) , //data {"username":xx","password":"xxx"}
                //规定发送的数据格式是json格式
                contentType:"applicaton/json",
                success:function(resp){ //服务器响应数据---解析成json
                    //处理resp
                    layer.msg(resp.msg, function () {
                        window.location = '/LayUI_war_exploded/index.html';
                    })
                },
                dataType:"json" //服务器响应格式
            })
           /* layer.msg('登录成功', function () {
                window.location = '/index.html';
            });*/
            return false;
        });
    });
</script>
</body>

LayUI异步登录2.servlet

@WebServlet("/admin_login")
public class AdminLoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        //这种方式不适合:前端application/json 数据格式
        //String username = request.getParameter("username");
        //System.out.println(username);

        //创建Map集合----存放前端提交所有参数
        Map<String,Object> parms = new HashMap<>() ;

        //获取前端提交的字节输入流
        ServletInputStream inputStream = request.getInputStream() ;
        //commons-IO-提供 IOUtils
        //public String toString(InputStream inputstraem,String encoding)
        //参数1:获取到post提交的内容 -- 保存在字节输入流中 (获取到流的内容)
        //参数2:编码 :支持utf-8
        String jsonStr = IOUtils.toString(inputStream, "utf-8");
        System.out.println(jsonStr) ;//{"username":"李国栋","password":"123456","captcha":"xszg"}
        //fastjson.jar包-- 工具栏JSON--将上面的这个json传解析成实体
        //JSONObject parseObject(String text, Class<T> class):参数1:获取json串,参数2:将对应的内容存在实体中,当前类型的字节码文件
        Map map = JSON.parseObject(jsonStr, Map.class);
        //System.out.println(map) ;//{password=123456, captcha=xszg, username=梁飞虎}
        parms.putAll(map) ;
        //遍历parms
       /* Set<Map.Entry<String, Object>> entries = parms.entrySet();
        for(Map.Entry<String,Object> entry:entries){
            //获取键和值
            String key = entry.getKey();
            String value = (String) entry.getValue();
            System.out.println(key+"--"+value);
        }*/
        String username = (String) parms.get("username");
        String password = (String) parms.get("password");
        System.out.println(username+"---"+password) ;
        //调用业务接口,通过用户名和密码完成登录逻辑
        AdminService adminService = new AdminServiceImpl() ;
        BaseResp baseResp = adminService.getAdminByName(username, password);
        //解析成json格式
        JSONObject jsonObject = new JSONObject() ;
        String  baseRespStr= jsonObject.toJSONString(baseResp);
        System.out.println(baseRespStr) ;
        response.setContentType("application/json;charset=utf-8");
        response.getWriter().write(baseRespStr) ;
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request,response);
    }
}

LayUI一步登陆3.service/dao

public class AdminServiceImpl  implements  AdminService{
    /**
     * 获取管理员信息,返回响应实体
     * @param username 管理员名称
     * @param password 密码
     * @return 返回结果对象
     */
    @Override
    public BaseResp getAdminByName(String username, String password) {
        try {
            AdminDao adminDao = new AdminDaoImpl() ;
            Admin admin = adminDao.selectAdminByName(username);
            if(admin!=null){
                //判断管理员密码
                if(password.equals(admin.getPassword())){
                    return  new BaseResp(0,"登录成功",null,null) ;
                }
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        //没有查到
        return new BaseResp(1,"error",null,null) ;
    }
}

public class AdminDaoImpl  implements AdminDao {
    @Override
    public Admin selectAdminByName(String username) throws SQLException {
        QueryRunner qr = new QueryRunner(DruidJdbcUtils.getDataSource()) ;
        String sql = "select * from admin where username = ?" ;
        Admin admin = qr.query(sql, new BeanHandler<>(Admin.class), username);
        return admin;
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class BaseResp {

    private Integer code ; //0表示数据,1表示没有数据
    private String msg ; //消息字符串提示内容
    private Object data ; //响应实际内容:实体或者list或者Map
    private Integer count ; //总记录
}

LayUI表格使用

 {
          "title": "用户管理",
          "href": "",
          "icon": "fa fa-flag-o",
          "target": "_self",
          "child": [
            {
              "title": "查询用户",
              "href": "/LayUI_war_exploded/page/admin/user_list.html",
              "icon": "fa fa-stumbleupon-circle",
              "target": "_self"
            }
          ]
        },

<head>
    <meta charset="UTF-8">
    <title>用户列表页面</title>
  <meta name="renderer" content="webkit">
  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
  <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
  <link rel="stylesheet" href="/LayUI_war_exploded/lib/layui-v2.5.5/css/layui.css" media="all">
  <link rel="stylesheet" href="/LayUI_war_exploded/css/public.css" media="all">
</head>
<body>

    <script type="text/html" id="toolbarDemo">
      <div class="layui-btn-container">
        <button class="layui-btn layui-btn-sm data-add-btn"> 添加用户 </button>
        <!--   <button class="layui-btn layui-btn-sm layui-btn-danger data-delete-btn"> 删除用户 </button>-->
      </div>
    </script>

    <!--删除-->
    <script type="text/html" id="barDemo">
      <a class="layui-btn layui-btn-danger layui-btn-xs" lay-event="del">删除</a>
    </script>

    <!--layui的过滤属性值-->
    <table class="layui-hide"
           id="currentTableId"

           lay-filter="currentTableFilter"></table>

    <script type="text/html" id="currentTableBar">
      <a href="shopadd.html" class="layui-btn layui-btn-xs data-count-edit" lay-event="edit">编辑</a>
      <a class="layui-btn layui-btn-xs layui-btn-danger data-count-delete" lay-event="delete">删除</a>
    </script>

  </div>
</div>
<script src="/LayUI_war_exploded/lib/layui-v2.5.5/layui.js" charset="utf-8"></script>
<script src="/LayUI_war_exploded/lib/jquery-3.4.1/jquery-3.4.1.min.js" charset="utf-8"></script>
<script>

  /*
  *   加载和初始化模块 表单模块,表格模块
  * */
  layui.use([ 'table','util'], function () {
    var table = layui.table, //给表格组件初始化
            util = layui.util;  //表格中的单元格编辑进行初始化

    table.render({
      //发送json数据
      elem: '#currentTableId', //获取当前table标签对象
      url: '/LayUI_war_exploded/findAllUser?page=1&limit=10', // 请求的后台接口
      toolbar: '#toolbarDemo',
      defaultToolbar: ['filter', 'exports', 'print', { //默认的工具栏: 右边:打印,导出,帅选列
        title: '',
        layEvent: 'LAYTABLE_TIPS',
        icon: 'layui-icon-tips'
      }],

      //表格中的数据内容
      cols: [[

        {type: "checkbox", width: 50, fixed: "left"},
              //field:实体属性名称
              //tittle:列的标题名称
        {field: 'uid', width: 80, title: '用户ID', sort: true},
        {field: 'username', width: 80, title: '用户名'},
        {field: 'password', width: 80, title: '密码'},
        {field: 'name', width: 80, title: '真实姓名'},
        {field: 'email', title: '邮箱', minWidth: 150},
        {field: 'birthday', width: 80, title: '出生日期', sort: true},
        {field: 'sex', width: 80, title: '性别'},
        {title: '操作', minWidth: 50, templet: '#currentTableBar', fixed: "right", align: "center"}
      ]],
      limit: 10,
      page: true/*开启分页*/
    });
    
    
   //监听单元格编辑
    //currentTableFilter table标签中的lay-filter属性值
    table.on('edit(currentTableFilter)', function(obj){
      var value = obj.value //得到修改后的值
              ,data = obj.data //得到所在行所有键值
              ,field = obj.field; //得到字段

      // layer.msg('[ID: '+ data.id +'] ' + field + ' 字段更改值为:'+ util.escape(value));
    });  
  
  
  
  
protected void doGet(HttpServletRequest request,
                         HttpServletResponse response) throws ServletException, IOException {

        //接收参数:page参数以及limit每页显示的条数
        //默认第一页,每页显示15条
        String page = request.getParameter("page");
        String limit = request.getParameter("limit");
        System.out.println(page+"---"+limit) ;
        int page_number = Integer.parseInt(page) ;
        int limit_number = Integer.parseInt(limit) ;

        //调用AdminService
        AdminService adminService = new AdminServiceImpl() ;
        BaseResp baseResp = adminService.findUserByPage(page_number, limit_number) ;

        //转换成json,响应前端
        //FastJson
        JSONObject jsonObject = new JSONObject();
        String jsonString = jsonObject.toJSONString(baseResp);
        System.out.println(jsonString);
        response.setContentType("applicaton/json;charset=utf-8") ;
        response.getWriter().write(jsonString);
    }    

前后端json数据

1.导包

        <!--json解析工具:阿里提供的
            可以将前端发送的json进行解析,
            或者也可以后端获取到数据,转换成json,给前端
        -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.78</version>
        </dependency>
        
        <!--commons-io-->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>

2.前端json(post提交)

 $.ajax({
                url:"/LayUI_war_exploded/admin_login",
                type:"post",
                //发送json数据---JSON.stringfy(
                data: JSON.stringify(data) , //data {"username":xx","password":"xxx"}
                //规定发送的数据格式是json格式
                contentType:"applicaton/json",
                success:function(resp){ //服务器响应数据---解析成json
                    //处理resp
                    layer.msg(resp.msg, function () {
                        window.location = '/LayUI_war_exploded/index.html';
                    })

                },
                dataType:"json" //服务器响应格式

            })

3.后端接收并响应json数据

 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        //这种方式不适合post提交:前端发送的application/json 数据格式
        //String username = request.getParameter("username");
        //System.out.println(username);

        //创建Map集合----存放前端提交所有参数
        Map<String,Object> parms = new HashMap<>() ;

        //获取前端提交的字节输入流
        ServletInputStream inputStream = request.getInputStream() ;
        //commons-IO-提供 IOUtils
        //public String toString(InputStream inputstraem,String encoding)
        //参数1:获取到post提交的内容 -- 保存在字节输入流中 (获取到流的内容)
        //参数2:编码 :支持utf-8
        String jsonStr = IOUtils.toString(inputStream, "utf-8");//io流数据转换为字符串形式的数据
     
        System.out.println(jsonStr) ;//{"username":"李国栋","password":"123456","captcha":"xszg"}
        //fastjson.jar包-- 工具栏JSON--将上面的这个json传解析成实体
        //JSONObject parseObject(String text, Class<T> class):参数1:获取json串,参数2:将对应的内容存在实体中,当前类型的字节码文件
     
        Map map = JSON.parseObject(jsonStr, Map.class);
        //System.out.println(map) ;//{password=123456, captcha=xszg, username=梁飞虎}
        parms.putAll(map) ;

        //遍历parms
       /* Set<Map.Entry<String, Object>> entries = parms.entrySet();
        for(Map.Entry<String,Object> entry:entries){
            //获取键和值
            String key = entry.getKey();
            String value = (String) entry.getValue();
            System.out.println(key+"--"+value);
        }*/
        String username = (String) parms.get("username");
        String password = (String) parms.get("password");

        //调用业务接口,通过用户名和密码完成登录逻辑
        AdminService adminService = new AdminServiceImpl() ;
        BaseResp baseResp = adminService.getAdminByName(username, password);
        //解析成json格式
        JSONObject jsonObject = new JSONObject() ;
        String  baseRespStr= jsonObject.toJSONString(baseResp);

     
        response.setContentType("application/json;charset=utf-8");
        response.getWriter().write(baseRespStr) ;

MyBatis

mybatis涉及的设计模式

在这里插入图片描述

mybatis核心配置文档结构

configuration(配置)
    properties(属性)
    settings(设置)
    typeAliases(类型别名)
    typeHandlers(类型处理器)
    objectFactory(对象工厂)
    plugins(插件)
    environments(环境配置)
		environment(环境变量)
            transactionManager(事务管理器)
            dataSource(数据源)
    databaseIdProvider(数据库厂商标识)
    mappers(映射器)
    
<?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">
<!--xx.dtd是xml文件约束,约束标签-->
<!--核心配置-->
<configuration>
    <!--属性配置,加载外部配置文件-->
    <properties resource="jdbc.properties"></properties>
    <!--实体类的别名配置-->
    <typeAliases>
        <package name="com.qf.pojo"/>
    </typeAliases>
    <!--配置插件-->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>
    <!--环境配置-->
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"/>
            <dataSource type="com.qf.datasource.MyDruidDataSourceFactory">
                <property name="driverClassName" value="${jdbc.driverClassName}"/>
                <!--连接数据库的地址-->
                <property name="url" value="${jdbc.url}"/>
                <!--用户名-->
                <property name="username" value="${jdbc.username}"/>
                <!--登录密码-->
                <property name="password" value="${jdbc.password}"/>
                <property name="maxActive" value="${jdbc.maxActive}"/>
            </dataSource>
        </environment>

        <!--配置其他环境-->
    </environments>
    <!--加载mapper映射器-->
    <mappers>
        <!--配置接口的包名-->
        <package name="com.qf.mapper"/>
    </mappers>
</configuration>

属性配置properties

 <!--属性配置,加载外部配置文件-->
    <properties resource="jdbc.properties"></properties>
 
jdbc.properties文件: 
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis_01?characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456
jdbc.maxActive=10

类型别名配置typeAliases

方式1:指定一个包名,MyBatis 会在包名下面搜索需要的 Java Bean
<typeAliases>
     <package name="com.qf.pojo"/>
</typeAliases>   


方式2:
  <!--type指定的当前实体类的完全限定名称
            alias:实体的类别名(自己指定,见名知意)
            这种方式麻烦(实体类很多,配置很多个typeAlias),可以直接指定实体类的包名
            所有的实体类的包名就是默认当前类名(建议小写),不区分大小写
        -->
    <typeAlias alias="user" type="com.qf.pojo.User"></typeAlias>
    <typeAlias alias="vouser" type="com.qf.pojo.VoUser"></typeAlias>
    <typeAlias alias="queryvo" type="com.qf.pojo.QueryVo"></typeAlias>

配置插件plugins

分页插件:
<plugins>
        <!--插件里面属性
            interceptor指定当前拦截器
        -->
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>

环境配置environments,druid连接池

1.配置druid连接池
  <!--环境配置,默认属于mysql数据库-->
    <environments default="mysql">
        <!--可以配置多个环境-->
        <environment id="mysql">
            <!--mybatis事务管理器,连接数据库操作-->
            <transactionManager type="JDBC"/>
            <!--启用druid连接池 -->
            <dataSource type="com.qf.datasource.MyDruidDataSourceFactory">
 				<!--配置连接池这个类中的属性参数 -->
                <!-- ${获取外部资源文件的key对应的内容} -->
         <property name="driverClassName" value="${jdbc.driverClassName}"/>
                <!--连接数据库的地址-->
                <property name="url" value="${jdbc.url}"/>
                <!--用户名-->
                <property name="username" value="${jdbc.username}"/>
                <!--登录密码-->
                <property name="password" value="${jdbc.password}"/>
                <property name="maxActive" value="${jdbc.maxActive}"/>
            </dataSource>
        </environment>

        <!--配置其他环境-->
        <!--<environment id="oracle">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>  -->
    </environments>

自定义数据源工厂--提供德鲁伊的数据源DruidDataSource
public class MyDruidDataSourceFactory  extends PooledDataSourceFactory {
    public MyDruidDataSourceFactory(){
        //给数据源进行初始化
        this.dataSource = new DruidDataSource() ;//创建德鲁伊数据源
    }
}


mybatis自带的连接池
        <environment id="mysql">
            <transactionManager type="JDBC"/>
            <!--启用mybatis自带的连接池-->
            <dataSource type="POOLED">
                <!--配置连接池这个类中的属性参数
                    org.apache.ibatis.datasource.pooled.PooledDataSource信息
                -->
                <!--驱动类-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!--连接数据库的地址-->
      <property name="url" value="jdbc:mysql://localhost:3306/mybatis_01"/>
                <!--用户名-->
                <property name="username" value="root"/>
                <!--登录密码-->
                <property name="password" value="123456"/>

映射配置mappers

方式1.将包内的映射器接口实现全部注册为映射器

实体类的包名,实体名必须和resources文件下的实体类配置文件的结构一致
com.ddl.mapper.EmployeeDao
配置文件resources下:com.ddl.mapper.EmployeeDao.xml

<!--加载mapper映射器-->
    <mappers>
        <!--配置接口的包名,对应-->
        <package name="com.qf.mapper"/>
    </mappers>


方式2. 使用相对于类路径的资源引用    
    <mappers>
        <!--配置多个mapper-->
     <mapper resource="com/qf/mapper/UserDao.xml"></mapper>
     <mapper resource="com/qf/mapper/ProductDao.xml"></mapper>
     <mapper resource="com/qf/mapper/OrderDao.xml"></mapper>-->
    </mappers>

数据访问接口Dao的配置

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--映射器的配置
    namesapce:名称空间指定接口的完全限定名称
-->
<mapper namespace="com.qf.mapper.UserDao">
        <!--大量的sql标签
            id必须和接口文件中的方法名必须一致
            当前接口中的方法有返回值,返回值如果是实体类型或者是List集合
            输出映射:resultType必须要指定为当前实体类型的完全限定名称
            输入映射 paramterType:如果当前接口中方法形式参数是一个实体类型,写上当前类的完全限定名称
            如果形式参数String/int,写成String/int/Integer
            mybatis中书写sql语句,也必须使用占位符号 #{实体类的属性名称一致}
        -->
      <!--插入用户-->
    <insert id="addUser" parameterType="com.qf.pojo.User">
        insert  into user(username,gender,age,address) values(#{username},#{gender},#{age},#{address})
    </insert>
    <select id="findAll" resultType="com.qf.pojo.User">
        select * from user
    </select>
    <!--更新用户-->
    <update id="updateUser" parameterType="com.qf.pojo.User">
        update user set username=#{username},gender = #{gender},age = #{age},address = #{address}
where id = #{id}
    </update>
    <!--删除用户-->
    <delete id="deleteUser" parameterType="int">
        delete from user where id = #{id}
    </delete>
</mapper>

crud实现

public class MybatisTest {
    private AccountDao accountDao ;
    private UserDao userDao ;
    private SqlSession sqlSession ;
    @Before
    public void init() throws IOException {
        //1)读取resource下面的mybatis-config.xml文件
        //org.apache.ibatis.io.Resources --InputStream getResourceAsStream(配置文件名称)
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        //2)创建一个对象SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder() ;
        //3)创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);//加载流对象 获取到工厂对象
        //4)创建 SqlSession---就是执行对象--底层就是PreparedStatement
        //SqlSession sqlSession = sqlSessionFactory.openSession();//自动提交
         sqlSession = sqlSessionFactory.openSession(false);//手动提交
        //5)获取AccountDao接口对象---通过mybatis的动态代理获取接口对象
        //mybatis的写法
      //  accountDao = sqlSession.getMapper(AccountDao.class);//接口类型字节码文件
        //ibatis的写法
        //List<Object> objects = sqlSession.selectList("com.qf.mapper.AccountDao.findAllAccounts");
        //使用动态代理,获得Dao接口的对象
        userDao = sqlSession.getMapper(UserDao.class) ;
    }

  添加实现
 @Test
    public void testAddUser(){
        //封装User对象
        User user = new User() ;
        user.setUsername("张蒋杰3") ;
        user.setGender("男3") ;
        user.setAge(23) ;
        user.setAddress("宝鸡市3") ;
        //调用方法
        userDao.addUser(user);
    	}
    }
  @After
    public void commitAndColose(){
        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }

优化–别名配置

每一个在包 domain.blog 中的 Java Bean,在没有注解的情况下,会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 domain.blog.Author 的别名为 author(不区分大小写);若有注解,则别名为其注解值。见下面的例子:
@Alias("author")
public class Author {
    ...
}
1.mybatis.xml核心配置中:
<typeAliases>
 <package name="com.qf.pojo"/>
 </typeAliases>
2. Dao.xml配置中
<!--<insert id="addUser" parameterType="com.qf.pojo.User" > 优化-->
<insert id="addUser" parameterType="user" >   <!--不区分大小写-->

mybatis模糊查询的语法${} 和 #{}

1.占位符#{}
  <select id="selectUsersByUserName" parameterType="java.lang.String" resultType="user">
        select * from user where username like #{username}
    </select>
<!--select * from user where username like concat(' %’,#{username}, ' %'
其中名为conat(‘%’,#{关键字},‘%’)-->

2.字符串拼接${}
使用字符串拼接符号 ${}  固定写法'%${value}%',不推荐,存在字符串拼接,可能导致sql注入
<select id="selectUsersByUserName" parameterType="java.lang.String" resultType="com.qf.pojo.User">
        select * from user where username like '%${value}%'
    </select>

模糊查询实现
  @Test
    public void testselectUsersByUserName(){
//List<User> users = userDao.selectUsersByUserName("%张%") ;
        List<User> users = userDao.selectUsersByUserName("张") ;
        if(users!=null || users.size()>0){
            for(User user:users){
                System.out.println(user);
            }
        }
    }

mybatis关于添加用户的时候,获取到最后一次插入数据id值

 <insert id="addUser" parameterType="user" >
   <!--在插入的时候,获取id自增长主键的值,配置一些函数
   selectKey
         属性
         	keyColumn:表的主键字段名称
         	keyProperty:实体类的属性名称
            resultType:返回值自增长主键的值类型:当前实体类的完全限定名称或者别名
            order:AFTER:在执行插入语句之后执行selectkey的语句获取最后一次id的值
 -->
        <selectKey keyColumn="id" keyProperty="id" resultType="int"  order="AFTER">
            <!--通过这个函数获取最后一次自增长主键的id值-->
            SELECT LAST_INSERT_ID() ;
        </selectKey>
        insert  into user(username,gender,age,address) values(#{username},#{gender},#{age},#{address})
    </insert>

id主键自增长
public void testAddUser(){
        //封装User对象
        User user = new User() ;
        System.out.println("插入前:"+user) ;
        user.setUsername("张蒋杰3") ;
        user.setGender("男3") ;
        user.setAge(23) ;
        user.setAddress("宝鸡市3") ;

        //调用方法
        userDao.addUser(user);
        System.out.println("插入后:"+user);  //显示自增长的id值

    }


通过uuid()查询主键
create table t_order(
id varchar (32)primary key, #字符型主键name varchar(50)
)default charset = utf8;

<mapper namespace="com.qf.mybatis.part1.basic.0rderDao">
<insert id="insert0rder" parameterType="order">
<selectKey keyProperty="id" resultType="String" order="BEFORE" ><!-- 插入之前-->
		SELECT REPLACE (UUID(), '-','')<!--适用于字符类型主键
</selectKey>
		INSERT INTO t_order(id, name) VALUES(#{id},#{name})
< /insert>
< /mapper>

mybatis多个参数传递

指定多个条件查询用户
方式1:使用mybatis参数绑定注解方式(推荐)
 <!--#{}里面的内容需要和@Param里面的参数名称一致 -->
<select id="findUserByMultConditon" resultType="user">
        select * from user where username = #{username} and address = #{address}
    </select>

//dao层
//启用mybatis的@Param注解--指定绑定参数名称,这个参数名称就是等会需要赋值的参数,自定义(#{参数名称})
    User findUserByMultConditon(@Param("username") String name, @Param("address") String addr) ;



方式2:按照参数的顺序进行查询,param1,param2...
 <!--指定多个条件查询用户
        按照参数的顺序进行查询,param1,param2....依次,不利于管理维护(不推荐)
    -->
   <select id="findUserByMultConditon" resultType="com.qf.pojo.User">
        select * from user where username = #{param1}  and address = #{param2}
    </select>
dao:
User findUserByMultConditon(String name,String addr) 



方式3:使用Map集合
    <!-- #{}里面的内容需要和map集合的key一致 -->
   <select id="findUserByMultConditon" resultType="com.qf.pojo.User">
        select * from user where username = #{name} and address  = #{addr}
    </select>
dao:
  //使用Map集合接收所有参数 --复杂类型
    //User findUserByMultConditon(Map<String,String> map) ;
实现: 
        Map map = new HashMap() ;
        map.put("name","黄老师") ;
        map.put("addr","咸阳市") ;
        User user = userDao.findUserByMultConditon(map);

 
        
方式4:使用自定义vo实体,将参数放在实体中
    <!--通过vo实体查询指定的用户
         参数形式QueryVo实体类型,里面包含另一个实体属性user属性
         获取到QueryVo对象.getUser().getUsername():获取到用户名
         一个实体类中的getXxx()里面xxx就是实体类的bean属性
         ognl简写表达式  get()去掉,第一个字母小写
    -->
<!--方法参数为对象时,可直接使用#{属性名}进行获取-->
    <select id="findUserByQueryVo" parameterType="queryvo" resultType="user">
            select * from user where username = #{user.username}
    </select>     

dao:       
  //通过自定义的实体类,将查询的参数封装到这个类中
    User findUserByMultConditon(VoUser voUser) ;  
        
实现: 
        VoUser voUser = new VoUser() ;
        voUser.setName("高圆圆") ;
        voUser.setAddr("西安市") ;
        User user = userDao.findUserByMultConditon(voUser);
        System.out.println(user); 
        
@Data
@NoArgsConstructor
@AllArgsConstructor
public class QueryVo {
    private User user ;
}

mybatis分页实现

导包
 <!--mybatis的分页插件-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.2</version>
        </dependency>

  
  
  @Test
    public void testFindAll() throws IOException {

        //通过mybatis的分页插件完成分页条件
        //PageHelper父类有一个API---
        //public static <E> Page<E> startPage(int pageNum, int pageSize)
        //当前页码1,每页显示3条
        PageHelper.startPage(1,3) ;
        //6)调用方法
        List<User> users = userDao.findAll(); //获取分页列表数据
        //创建PageInfo对象
        PageInfo pageInfo = new PageInfo(users) ;
        System.out.println(pageInfo); //展示分页的数据
        if(users!=null || users.size()>0){
            for(User user :users){
                System.out.println(user);
            }
        }
    }
    
    

日志

 Mybatis 通过使用内置的日志工厂提供日志功能。内置日志工厂将会把日志工作委托给下面的实现之一:
SLF4J
Apache Commons Logging
Log4j 2
Log4j
JDK logging

MyBatis 内置日志工厂会基于运行时检测信息选择日志委托实现。它会(按上面罗列的顺序)使用第一个查找到的实现。当没有找到这些实现时,将会禁用日志功能 

     
步骤 1:添加 Log4J 的 jar 包
  <!--log4j的日志包-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
     
步骤 2:配置 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, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE


#跟踪具体的接口或者接口中的指定方法
#log4j.logger.com.qf.mapper.UserDao.addEmployee=TRACE,跟踪接口中的指定方法
 # 跟踪具体的接口       
log4j.logger.com.qf.mapper.EmployeeDao=TRACE

# 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=E:/Java/QFJava/mybatis_exercise/log4j.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
     
     
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值