Mybatis

最新推荐文章于 2021-04-23 16:15:18 发布

ok_1234

最新推荐文章于 2021-04-23 16:15:18 发布

阅读量130

点赞数

分类专栏： java笔记 Mybatis

本文链接：https://blog.csdn.net/ok_1234/article/details/108318150

版权

java笔记同时被 2 个专栏收录

16 篇文章 0 订阅

订阅专栏

Mybatis

2 篇文章 0 订阅

订阅专栏

1、简介

1.1.持久化

数据持久化

持久化就是将程序的数据在持久状态和瞬时状态转换的过程
内存：断电即失
数据库（Jdbc),io文件持久化

为什么需要持久化？
有些对象，不能让他丢掉。

内存太贵了

1.2.持久层

Dao层，Service层，Controller层…

完成持久化工作的代码块
层界限十分明显

1.3.为什么需要Mybatis

方便
传统的JDBC代码太复杂了、简化、框架、自动化
不用Mybatis也可以。更容易上手。
优点：
- 简单易学
- 灵活
- sql和代码的分离，提高了可维护性
- 提供映射标签，支持对象与数据库的ORM字段关系映射
- 提供对象关系映射标签，支持对象关系组建维护
- 提供xml标签，支持编写动态sql

2、第一个Mybatis程序

思路：搭建环境–>导入Mybatis–>编写代码–>测试！

2.1、搭建环境

搭建数据库

CREATE DATABASE `mybatis`;

USE `mybatis`;

CREATE TABLE  `user`(
	`id` INT(20) NOT NULL PRIMARY KEY,
	`name` VARCHAR(30)  DEFAULT NULL,
	`pwd`  VARCHAR(30) DEFAULT NULL
	)ENGING=INNODB DEFULT CHARSET=UTF8;
INSERT INTO `USER` (`id`,`name`,`pwd`) VALUES
(1,'张三'，‘123456’),
(2,'李四'，‘234343’),
(3,'王五'，‘789734’）

新建项目

新建一个普通的maven项目
删除src目录
导入maven依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!--父工程-->
    <groupId>org.example</groupId>
    <artifactId>Mybatis</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>mybatis-01</module>
        <module>Mybatis-02</module>
    </modules>

    <!--导入依赖-->
    <dependencies>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.8</version>
        </dependency>

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>

        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
    </project>

2.2、创建一个模块

mybatis的配置类

<?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核心配置文件-->
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value=""/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="com/zhou/dao/UserMapper.xml"></mapper>
    </mappers>
</configuration>

编写mybatis工具类

package com.zhou.utils;

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 java.io.IOException;
import java.io.InputStream;

/**
 * @auther zj
 * @create 2020-08-01 16:44
 */

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;

    static {

        try {
            //使用mybatis第一步:获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

        /**
         * 既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。
         * SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。
         */
        public static SqlSession getSqlSession(){
            return sqlSessionFactory.openSession();

        }

}

2.3、编写代码

实体类

package com.zhou.pojo;

/**
 * @auther zj
 * @create 2020-08-01 18:51
 */

public class User {
    private int id;
    private String name;
    private String pwd;


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }
}

Dao接口

package com.zhou.dao;

import com.zhou.pojo.User;

import java.util.List;
import java.util.Map;

/**
 * @auther zj
 * @create 2020-08-01 18:55
 */

public interface UserDao {
    List<User> getUserList();

    User getUserById(int id);

    User getUserById2(Map<String,Object> map);

    int addUser2(Map<String,Object> map);

    int addUser(User user);

    int updateUser(User user);

    int deletUserById(int id);
}

接口实现类由原来的UserDaoImpl转变为一个Mapper配置文件。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace =绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.zhou.dao.UserDao">
    <insert id="addUser" parameterType="com.zhou.pojo.User">
        insert into mybatis.user (id,name,pwd) values (#{id},#{name},#{pwd});
    </insert>
    <insert id="addUser2" parameterType="map">
        insert into mybatis.user (id,name,pwd) values (#{userId},#{userName},#{password});
    </insert>
    <update id="updateUser" parameterType="com.zhou.pojo.User">
        update mybatis.user set name=#{name},pwd=#{pwd} where id = #{id};
    </update>
    <delete id="deletUserById" parameterType="com.zhou.pojo.User">
        delete from mybatis.user where id = #{id};
    </delete>
    <select id="getUserList" resultType="com.zhou.pojo.User">
        select * from mybatis.user;
    </select>
    <select id="getUserById" resultType="com.zhou.pojo.User">
        select * from mybatis.user where id = #{id};
    </select>
    <select id="getUserById2" parameterType="map" resultType="com.zhou.pojo.User">
        select * from mybatis.user where id = #{userId};
    </select>
</mapper>

2.4 测试

注意点：org.apache.ibatis.binding.BindingException: Type interface com.zhou.dao.UserDao is not known to the MapperRegistry.

MapperRegistry是什么？
核心配置文件中注册mappers

junit测试

 @Test
    public void test(){
        //第一步：获得sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //执行SQL
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userList = userDao.getUserList();
        for (User user:userList){
            System.out.println(user);
        }
        sqlSession.close();
    }

    @Test
    public void testGetUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        User user = userDao.getUserById(1);
        System.out.println(user);
        sqlSession.close();

    }

可能会遇到的问题：

配置文件没有注册
绑定接口错误
方法名不对
返回名不对
maven导出资源

3.CRUD

1、namespace

namespace中的包名要和Dao/mapper接口的包名一致

2、Select

选择、查询语句；

id：就是对应的namespace中的方法名；
resultType: Sql语句执行的返回值！
parameterType:参数类型

<select id="getUserList" resultType="com.zhou.pojo.User">
        select * from mybatis.user;
    </select>

1.编写接口

package com.zhou.dao;

import com.zhou.pojo.User;

import java.util.List;
import java.util.Map;

/**
 * @auther zj
 * @create 2020-08-01 18:55
 */

public interface UserDao {
    List<User> getUserList();

    User getUserById(int id);

    User getUserById2(Map<String,Object> map);

    int addUser2(Map<String,Object> map);

    int addUser(User user);

    int updateUser(User user);

    int deletUserById(int id);
}

2.编写对应的mapper中的sql语句

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace =绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.zhou.dao.UserDao">
    <insert id="addUser" parameterType="com.zhou.pojo.User">
        insert into mybatis.user (id,name,pwd) values (#{id},#{name},#{pwd});
    </insert>
    <insert id="addUser2" parameterType="map">
        insert into mybatis.user (id,name,pwd) values (#{userId},#{userName},#{password});
    </insert>
    <update id="updateUser" parameterType="com.zhou.pojo.User">
        update mybatis.user set name=#{name},pwd=#{pwd} where id = #{id};
    </update>
    <delete id="deletUserById" parameterType="com.zhou.pojo.User">
        delete from mybatis.user where id = #{id};
    </delete>
    <select id="getUserList" resultType="com.zhou.pojo.User">
        select * from mybatis.user;
    </select>
    <select id="getUserById" resultType="com.zhou.pojo.User">
        select * from mybatis.user where id = #{id};
    </select>
    <select id="getUserById2" parameterType="map" resultType="com.zhou.pojo.User">
        select * from mybatis.user where id = #{userId};
    </select>
</mapper>

3.测试

package com.zhou.dao;

import com.zhou.pojo.User;
import com.zhou.utils.MybatisUtils;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @auther zj
 * @create 2020-08-01 19:04
 */

public class UserDaoTest {

    @Test
    public void test(){
        //第一步：获得sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //执行SQL
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userList = userDao.getUserList();
        for (User user:userList){
            System.out.println(user);
        }
        sqlSession.close();
    }

    @Test
    public void testGetUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        User user = userDao.getUserById(1);
        System.out.println(user);
        sqlSession.close();

    }

    @Test
    public void testGetUserById2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        Map<String,Object> map = new HashMap<>();
        map.put("userId",1);
        User user = userDao.getUserById2(map);
        System.out.println(user);
        sqlSession.close();

    }

    //增删改需要提交事物
    @Test
    public void testAddUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        User user = new User(4, "李倩","123456");
        int testUser = userDao.addUser(user);
        System.out.println(testUser);
        if(testUser>0){
            System.out.println("插入成功！");
        }
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void testAddUser2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("userId",5);
        map.put("userName","明天");
        map.put("password","12349090");

        int testUser = userDao.addUser2(map);
        System.out.println(testUser);
        if(testUser>0){
            System.out.println("插入成功！");
        }
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void updateUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        int result = userDao.updateUser(new User(2,"小明","000000"));
        if(result>0){
            System.out.println("更新数据成功");
        }
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    public void deleteUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        int result = userDao.deletUserById(2);
        if(result>0){
            System.out.println("删除数据成功");
        }
        sqlSession.commit();
        sqlSession.close();
    }
}

3、insert

 <insert id="addUser2" parameterType="map">
        insert into mybatis.user (id,name,pwd) values (#{userId},#{userName},#{password});
    </insert>

4、update

  <delete id="deletUserById" parameterType="com.zhou.pojo.User">
        delete from mybatis.user where id = #{id};
    </delete>

5、Delete

 <delete id="deletUserById" parameterType="com.zhou.pojo.User">
        delete from mybatis.user where id = #{id};
    </delete>

注意点：

增删改需要提交事物！

6、分析错误

标签不要匹配错
resource绑定mapper，需要使用路径
程序配置文件必须符合规范！
nullPointExcception,没有注册资源
输出的xml文件中存在中文乱码问题！
maven资源没有导出

7、万能Map

假设，我们的实体类，或者数据库中的表，字段或者参数过多，我们应当考虑使用Map

User getUserById2(Map<String,Object> map);

<insert id="addUser2" parameterType="map">
        insert into mybatis.user (id,name,pwd) values (#{userId},#{userName},#{password});
    </insert>

  @Test
    public void testAddUser2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("userId",5);
        map.put("userName","明天");
        map.put("password","12349090");

        int testUser = userDao.addUser2(map);
        System.out.println(testUser);
        if(testUser>0){
            System.out.println("插入成功！");
        }
        sqlSession.commit();
        sqlSession.close();
    }

Map传递参数，直接在sql中取出key即可！【parameterType=“map”】
对象传递参数，直接在sql中取队形的属性即可！【parameterType=“Object”】
只有一个基本类型参数的情况下，可以直接在sql中取到！
多个参数用Map，或者注解！

8、模糊查询怎么写？

Java代码执行的时候，传递通配符%%

List<User> userList = userDao.getUserLike("%张%");

在sql拼接中使用通配符

select * from mybatis.user where name like "%" #{param} "%";

4、配置解析

1、核心配置文件

mybatis-config.xml

configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）

2、环境配置（environments)

myBatis可以配置成适应多种环境

不过要记住：尽管可以配置多个环境，但每个SqlSessionFactory实例只能选择一种环境。
学会使用配置多套运行环境！
mybatis默认的事务管理器就是JDBC,连接池：POOLED

3、属性（properties）

我们可以通过properties属性来实现引用配置文件
这些属性都是可外部配置且可动态替换的，即可以在典型的Java属性文件中配置，亦可通过properties元素的子元素来传递。【db.properties】
编写一个配置文件
db.properties

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

在核心配置文件中引入

<!--引入外部配置文件-->
    <properties resource="db.properties">
		<property name="username" value="root"/>
		<property name="pwd" value="111"/>
	</properties>

可以直接引入外部问文件
可以在其中增加一些属性配置
如果两个文件有同一个字段，优先使用外部配置文件的！

4、类型别名（typeAliases)

类型别名是为Java类型设置一个短的名字
存在的意义仅在于用来减少类完全限定名的冗余

<!--给实体类起别名-->
    <typeAliases>
        <typeAlias type="com.zhou.pojo.User" alias="User"></typeAlias>
    </typeAliases>

也可以指定一个包名，MyBatis会在包名下面搜索需要的Java Bean,比如：扫描实体类的包，它的莫仍别名就为这个类的类名，首字母小写，大写也是可以的。

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

在实体类比较少的时候，使用第一种方式。
如果实体类十分多，建议使用第二种。

第一种可以DIY,第二种‘不可以’，如果非要改，需要在实体上增加注解

@Alias("user")
public class User{}

5、设置

这是Mybatis中极为重要的调整设置，他们会改变Mybatis的运行时行为。

6、其他配置

typeHandlers(类型处理器）
objectFactory(对象工厂)
plugins(插件）
- mybatis-generator-core
- mybatis-plus
- 通用mapper

7、映射器

MapperRegistry:注册绑定我们的Mapper文件；
方式一：

<mappers>
        <mapper resource="com/zhou/dao/UserMapper.xml"></mapper>
 </mappers>

方式二：使用class文件绑定注册

<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->
<mappers>
        <mapper class="com.zhou.dao.UserMapper"></mapper>
</mappers>

注意点：

接口和他的Mapper配置文件必须同名！
接口和他的Mapper配置文件必须在同一个包下！

方式三：使用扫描包进行注入绑定

<mappers>
<!--        <mapper resource="com/zhou/dao/UserMapper.xml"></mapper>-->
        <package name="com.zhou.dao"/>
</mappers>

注意点：

接口和他的Mapper配置文件必须同名！
接口和他的Mapper配置文件必须在同一个包下！

8、生命周期和作用域

生命周期和作用域，是至关重要的，因为错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder:

一旦创建了SqlSessionFactory，就不再需要它了
局部变量

SqlSessionFactory:

说白了就是可以想象为：数据库连接池
SqlSessionFactory一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。
因此sqlSessionFactory的最佳作用域是应用作用域
最简单的就是使用单例模式或者静态单例模式

SqlSession

连接到连接池的一个请求！
SqlSession的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
用完之后需要赶紧关闭

在这里插入图片描述
这里的每一个Mapper,就代表一个具体的业务！

5、解决属性名和字段名不一致的问题

解决方法：

起别名

<select id="getUserById" parameterType="int" resultType="User">
        select id,name,pwd from mybatis.user where id = #{id};
</select>

2、resultMap

结果集映射

id  name pwd
id name password

 <!--结果集映射-->
    <resultMap id="UserMap" type="User">
        <result column="id" property="id"></result>
        <result column="name" property="name"></result>
        <result column="pwd" property="password"></result>
    </resultMap>
    <select id="getUserById" parameterType="int" resultMap="UserMap">
        select * from mybatis.user where id = #{id};
    </select>

resultMap元素是MyBatis中最重要强大的元素
ResuMap的设计思想是，对于简单的语句根本不需要配置显式的结果映射，而对于复杂一点的语句只需要描述它们的关系就行了。

6、日志

6.1、日志工厂

如果一个数据库操作，出现了异常，我们需要排错。日志就是最好的助手！
曾经：sout、debug
现在：日志工厂！

SLF4J
LOG4J【掌握】
LOG4J2
JDK_LOGGING
COMMONS_LOGGING
STDOUT_LOGGING 【掌握】
NO_LOGGING

在Mybatis中具体使用哪个日志实现，在设置中设定！
STDOUT_LOGGING标准日志输出
在mybatis核心设置文件中，配置我们的日志！

<settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

Opening JDBC Connection
Created connection 682376643.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@28ac3dc3]
==>  Preparing: select * from mybatis.user; 
==> Parameters: 
<==    Columns: id, name, pwd
<==        Row: 1, 张三, 123456
<==        Row: 3, 王五, 678686
<==        Row: 4, 李倩, 123456
<==        Row: 5, 明天, 12349090
<==      Total: 4
User{id=1, name='张三', password='123456'}
User{id=3, name='王五', password='678686'}
User{id=4, name='李倩', password='123456'}
User{id=5, name='明天', password='12349090'}

6.2、Log4j

什么是log4j？

Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
我们也可以控制每一条日志的输出格式
通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程
通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

1、先导入log4j的包

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

2、创建log4j.properties

# priority  :debug<info<warn<error
#you cannot specify every priority with different file for log4j
log4j.rootLogger=debug,stdout,info,debug,warn,error 

#console
log4j.appender.stdout=org.apache.log4j.ConsoleAppender 
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 
log4j.appender.stdout.layout.ConversionPattern= [%d{yyyy-MM-dd HH:mm:ss a}]:%p %l%m%n
#info log
log4j.logger.info=info
log4j.appender.info=org.apache.log4j.DailyRollingFileAppender 
log4j.appender.info.DatePattern='_'yyyy-MM-dd'.log'
log4j.appender.info.File=./src/main/java/log/info.log
log4j.appender.info.Append=true
log4j.appender.info.Threshold=INFO
log4j.appender.info.layout=org.apache.log4j.PatternLayout 
log4j.appender.info.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss a} [Thread: %t][ Class:%c >> Method: %l ]%n%p:%m%n
#debug log
log4j.logger.debug=debug
log4j.appender.debug=org.apache.log4j.DailyRollingFileAppender 
log4j.appender.debug.DatePattern='_'yyyy-MM-dd'.log'
log4j.appender.debug.File=./src/main/java/log/debug.log
log4j.appender.debug.Append=true
log4j.appender.debug.Threshold=DEBUG
log4j.appender.debug.layout=org.apache.log4j.PatternLayout 
log4j.appender.debug.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss a} [Thread: %t][ Class:%c >> Method: %l ]%n%p:%m%n
#warn log
log4j.logger.warn=warn
log4j.appender.warn=org.apache.log4j.DailyRollingFileAppender 
log4j.appender.warn.DatePattern='_'yyyy-MM-dd'.log'
log4j.appender.warn.File=./src/main/java/log/warn.log
log4j.appender.warn.Append=true
log4j.appender.warn.Threshold=WARN
log4j.appender.warn.layout=org.apache.log4j.PatternLayout 
log4j.appender.warn.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss a} [Thread: %t][ Class:%c >> Method: %l ]%n%p:%m%n
#error
log4j.logger.error=error
log4j.appender.error = org.apache.log4j.DailyRollingFileAppender
log4j.appender.error.DatePattern='_'yyyy-MM-dd'.log'
log4j.appender.error.File = ./src/main/java/log/error.log 
log4j.appender.error.Append = true
log4j.appender.error.Threshold = ERROR 
log4j.appender.error.layout = org.apache.log4j.PatternLayout
log4j.appender.error.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss a} [Thread: %t][ Class:%c >> Method: %l ]%n%p:%m%n

3.配置log4j为日志的实现

<settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>

4.Log4j的使用！直接运行

简单使用

在要使用Log4j的类中，导入包import org.apache.log4j.Logger;
日志对象，参数为当前类的class

static Logger logger = Logger.getLogger(UserTest.class);

日志级别

		logger.info("info:进入了testLog4j");
        logger.debug("debug:进入了testLog4j");
        logger.error("error:进入了testLog4j");

7、分页

思考：为什么要分页

减少数据的查询

使用Limit分页

select * from user limit 3;

使用Mybatis实现分页，核心SQL
1.接口

List<User> users = (List<User>) mapper.getUserByLimit(map);

2.Mapper.xml

<select id="getUserByLimit" resultType="User" parameterType="map">
        select * from user limit #{startIndex},#{endIndex}
    </select>

3.测试

@Test
    public void getUserByLimit(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        HashMap<String,Integer> map = new HashMap<String, Integer>();
        map.put("startIndex",0);
        map.put("endIndex",3);
        List<User> users = (List<User>) mapper.getUserByLimit(map);
        for(User user :users){
            System.out.println(user);
        }
        }
        sqlSession.close();

7.2 RowBouds分页

不再使用SQL实现分页
1.接口

List<User> getUserRowBouds(Map<String,Integer> map);

2.mapper.xml

 <select id="getUserRowBouds" resultMap="UserMap">
        select * from user
    </select>

3.测试

@Test
    public void getUserByRowBouds(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //RowBounds实现
        RowBounds rowBounds = new RowBounds(1,2);

        //通过Java代码层面实现分页
         List<User> userList = sqlSession.selectList("zhou.dao.UserMapper.getUserRowBouds",null,rowBounds);

         for(User user : userList ){
             System.out.println(user);
         }

         sqlSession.close();
    }

7.3分页查询插件

MyBatis pageHandler

8、使用注解开发

8.1、面向接口编程

很多时候我们会选择面向接口编程
**根本原因：**解耦，可拓展，提高复用，分层开发中，上层不用管具体的实现，大家都遵守共同的标准，使得开发变得容易，规范性更好。
在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的，对系统设计人员来讲就不那么重要了；
而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，达到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。

关于接口的理解

接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。
接口的本身反映了系统设计人员对系统的抽象理解。
接口应有两类：
- 第一类是对一个个体的抽象，它可对应为一个抽象体（abstract class);
- 第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）；
- 一个体有可能有多个抽象面。抽象体与抽象面是有区别的。

三个面向区别

面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法。
面向过程是指，我们考虑问题时，以一个具体的流程（事物过程）为单位，考虑它的实现
接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题。更多的体现就是对系统整体的架构。

8.2、使用注解开发

注解在接口上实现

@Select("select * from user")
    List<User> getUserList();

需要在核心配置文件中绑定接口！

<mappers>
        <mapper class="zhou.dao.UserMapper"/>
    </mappers>

测试

 @Test
    public void testGetUserList(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        //底层主要应用反射
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.getUserList();
        for(User user : users){
            System.out.println(user);
        }

    }

本质：反射机制实现
底层：动态代理
在这里插入图片描述

MyBatis执行流程
在这里插入图片描述

ok_1234

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mybatis

1、简介1.1.持久化数据持久化持久化就是将程序的数据在持久状态和瞬时状态转换的过程内存：断电即失数据库（Jdbc),io文件持久化为什么需要持久化？有些对象，不能让他丢掉。内存太贵了1.2.持久层Dao层，Service层，Controller层…完成持久化工作的代码块层界限十分明显1.3.为什么需要Mybatis方便传统的JDBC代码太复杂了、简化、框架、自动化不用Mybatis也可以。更容易上手。优点：简单易学灵活sql和代码的分离，提高了可维护
复制链接

扫一扫