构建

描述

SqlSession

作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库增删改查功能

Executor

MyBatis执行器，是MyBatis调度的核心，负责SQL语句的生成和查询缓 存的维护

StatementHandler

封装了JDBC Statement操作，负责对JDBC statement的操作，如设置参数、将Statement结果集转换成List集合。

ParameterHandler

负责对用户传递的参数转换成JDBC Statement所需要的参数

ResultSetHandler

负责将JDBC返回的ResultSet结果集对象转换成List类型的集合

TypeHandler

负责java数据类型和jdbc数据类型之间的映射和转换

MappedStatement

MappedStatement维护了一条＜select|update|insert|delete>节点的封装

SqlSouce

负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封

BoundSql

表示动态生成的SQL语句以及相应的参数信息

CacheKey cacheKey = new CacheKey();

//MappedStatement 的 id

// id就是Sql语句的所在位置包名+类名+ SQL名称

cacheKey.update(ms.getId());

// offset 就是 0

cacheKey.update(rowBounds.getOffset());

// limit 就是 Integer.MAXVALUE

cacheKey.update(rowBounds.getLimit());

//具体的SQL语句

cacheKey.update(boundSql.getSql());

//后面是update 了 sql中带的参数

cacheKey.update(value);

...

if (configuration.getEnvironment() != null) {

// issue #176

cacheKey.update(configuration.getEnvironment().getId());

}

<environments default="development">

<environment id="development">

<transactionManager type="JDBC"/>

<dataSource type="POOLED">

<property name="driver" value="${jdbc.driver}"/>

<property name="url" value="${jdbc.url}"/>

<property name="username" value="${jdbc.username}"/>

<property name="password" value="${jdbc.password}"/>

</dataSource>

</environment>

</environments>

Override

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds

rowBounds, ResultHandler resultHandler) throws SQLException {

BoundSql boundSql = ms.getBoundSql(parameter);

//创建缓存

CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);

return query(ms, parameter, rowBounds, resultHandler, key, boundSql);

}

@SuppressWarnings("unchecked")

Override

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds

rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws

SQLException {

...

list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;

if (list != null) {

//这个主要是处理存储过程用的。

handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);

} else {

list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key,

boundSql);

}

...

}

// queryFromDatabase 方法

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter,

RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql

boundSql) throws SQLException {

List<E> list;

localCache.putObject(key, EXECUTION_PLACEHOLDER);

try {

list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);

} finally {

localCache.removeObject(key);

}

localCache.putObject(key, list);

if (ms.getStatementType() == StatementType.CALLABLE) {

localOutputParameterCache.putObject(key, parameter);

}

return list;

}

private Map<Object, Object> cache = new HashMap<Object, Object>();

@Override

public void putObject(Object key, Object value) { cache.put(key, value);

}

<!--开启二级缓存-->

<settings>

    <setting name="cacheEnabled" value="true"/>

  </settings>

<!--开启二级缓存-->

<cache></cache>

public class PerpetualCache implements Cache {

private final String id;

private MapcObject, Object> cache = new HashMapC);

public PerpetualCache(St ring id) { this.id = id;

}

public class User implements Serializable(

//用户ID

private int id;

//用户姓名

private String username;

//用户性别

private String sex;

}

<select id="selectUserByUserId" useCache="false"

resultType="com.lagou.pojo.User" parameterType="int">

select * from user where id=#{id}

</select>

<select id="selectUserByUserId" flushCache="true" useCache="false"

resultType="com.lagou.pojo.User" parameterType="int">

select * from user where id=#{id}

</select>

<dependency>

<groupId>org.mybatis.caches</groupId>

<artifactId>mybatis-redis</artifactId>

<version>1.0.0-beta2</version>

</dependency>

<?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">

<mapper namespace="com.lagou.mapper.IUserMapper">

<cache type="org.mybatis.caches.redis.RedisCache" />

<select id="findAll" resultType="com.lagou.pojo.User" useCache="true">

select * from user

</select>

redis.host=localhost

redis.port=6379

redis.connectionTimeout=5000

redis.password=

redis.database=0

@Test

public void SecondLevelCache(){

SqlSession sqlSession1 = sqlSessionFactory.openSession();

SqlSession sqlSession2 = sqlSessionFactory.openSession();

SqlSession sqlSession3 = sqlSessionFactory.openSession();

IUserMapper mapper1 = sqlSession1.getMapper(IUserMapper.class);

lUserMapper mapper2 = sqlSession2.getMapper(lUserMapper.class);

lUserMapper mapper3 = sqlSession3.getMapper(IUserMapper.class);

User user1 = mapper1.findUserById(1);

sqlSession1.close(); //清空一级缓存

User user = new User();

user.setId(1);

user.setUsername("lisi");

mapper3.updateUser(user);

sqlSession3.commit();

User user2 = mapper2.findUserById(1);

System.out.println(user1==user2);

}

public final class RedisCache implements Cache {

public RedisCache(final String id) {

if (id == null) {

throw new IllegalArgumentException("Cache instances require anID");

}

this.id = id;

RedisConfig redisConfig =

RedisConfigurationBuilder.getInstance().parseConfiguration();

pool = new JedisPool(redisConfig, redisConfig.getHost(),

redisConfig.getPort(),

redisConfig.getConnectionTimeout(),

redisConfig.getSoTimeout(), redisConfig.getPassword(),

redisConfig.getDatabase(), redisConfig.getClientName());

}

public class RedisConfig extends JedisPoolConfig {

private String host = Protocol.DEFAULT_HOST;

private int port = Protocol.DEFAULT_PORT;

private int connectionTimeout = Protocol.DEFAULT_TIMEOUT;

private int soTimeout = Protocol.DEFAULT_TIMEOUT;

private String password;

private int database = Protocol.DEFAULT_DATABASE;

private String clientName;

public RedisConfig parseConfiguration(ClassLoader classLoader) {

Properties config = new Properties();

InputStream input =

classLoader.getResourceAsStream(redisPropertiesFilename);

if (input != null) {

try {

config.load(input);

} catch (IOException e) {

throw new RuntimeException(

"An error occurred while reading classpath property '"

+ redisPropertiesFilename

+ "', see nested exceptions", e);

} finally {

try {

input.close();

} catch (IOException e) {

// close quietly

}

}

}

RedisConfig jedisConfig = new RedisConfig();

setConfigProperties(config, jedisConfig);

return jedisConfig;

}

host=localhost

port=6379

connectionTimeout=5000

soTimeout=5000

password= database=0 clientName=

private Object execute(RedisCallback callback) {

Jedis jedis = pool.getResource();

try {

return callback.doWithRedis(jedis);

} finally {

jedis.close();

}

}

public interface RedisCallback {

Object doWithRedis(Jedis jedis);

}

@Override

public void putObject(final Object key, final Object value) {

execute(new RedisCallback() {

@Override

public Object doWithRedis(Jedis jedis) {

jedis.hset(id.toString().getBytes(), key.toString().getBytes(),

SerializeUtil.serialize(value));

return null;

}

});

}

@Override

public Object getObject(final Object key) {

return execute(new RedisCallback() {

@Override

public Object doWithRedis(Jedis jedis) {

return SerializeUtil.unserialize(jedis.hget(id.toString().getBytes(),

key.toString().getBytes()));

}

});

}

public ParameterHandler newParameterHandler(MappedStatement mappedStatement,

Object object, BoundSql sql, InterceptorChain interceptorChain){

  ParameterHandler parameterHandler =

mappedStatement.getLang().createParameterHandler(mappedStatement,object,sql);

parameterHandler = (ParameterHandler)

interceptorChain.pluginAll(parameterHandler);

return parameterHandler;

}

public Object pluginAll(Object target) {

for (Interceptor interceptor : interceptors) {

target = interceptor.plugin(target);

}

return target;

}

@Intercepts({

@Signature(

type = Executor.class,

method = "query",

args=

{MappedStatement.class,Object.class,RowBounds.class,ResultHandler.class}

)

})

public class ExeunplePlugin implements Interceptor {

//省略逻辑

}

<plugins>

<plugin interceptor="com.lagou.plugin.ExamplePlugin">

</plugin>

</plugins>

Intercepts ({//注意看这个大花括号，也就这说这里可以定义多个@Signature对多个地方拦截，都用这

个拦截器

@Signature (type = StatementHandler .class , //这是指拦截哪个接口

    method = "prepare"，//这个接口内的哪个方法名，不要拼错了

    args = { Connection.class, Integer .class}), 这是拦截的方法的入参，按顺

序写到这，不要多也不要少，如果方法重载，可是要通过方法名和入参来确定唯一的

})

public class MyPlugin implements Interceptor {

private final Logger logger = LoggerFactory.getLogger(this.getClass());

// //这里是每次执行操作的时候，都会进行这个拦截器的方法内

Override

public Object intercept(Invocation invocation) throws Throwable {

//增强逻辑

System.out.println("对方法进行了增强....")；

return invocation.proceed(); //执行原方法

}

/**

* //主要是为了把这个拦截器生成一个代理放到拦截器链中

* ^Description包装目标对象 为目标对象创建代理对象

* @Param target为要拦截的对象

* @Return代理对象

*/

Override

public Object plugin(Object target) {

System.out.println("将要包装的目标对象："+target);

return Plugin.wrap(target,this);

 }

/**获取配置文件的属性**/

//插件初始化的时候调用，也只调用一次，插件配置的属性从这里设置进来

Override

  public void setProperties(Properties properties) {

System.out.println("插件配置的初始化参数："+properties );

}

}

<plugins>

<plugin interceptor="com.lagou.plugin.MySqlPagingPlugin">

<!--配置参数-->

<property name="name" value="Bob"/>

</plugin>

</plugins

public interface UserMapper {

List<User> selectUser();

}

<mapper namespace="com.lagou.mapper.UserMapper">

<select id="selectUser" resultType="com.lagou.pojo.User">

SELECT

id,username

FROM

user

</select>

</mapper>

public class PluginTest {

@Test

public void test() throws IOException {

InputStream resourceAsStream =

Resources.getResourceAsStream("sqlMapConfig.xml");

SqlSessionFactory sqlSessionFactory = new

SqlSessionFactoryBuilder().build(resourceAsStream);

SqlSession sqlSession = sqlSessionFactory.openSession();

UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

List<User> byPaging = userMapper.selectUser();

for (User user : byPaging) {

System.out.println(user);

}

}

}

<dependency>

    <groupId>com.github.pagehelper</groupId>

    <artifactId>pagehelper</artifactId>

    <version>3.7.5</version>

  </dependency>

  <dependency>

    <groupId>com.github.jsqlparser</groupId>

    <artifactId>jsqlparser</artifactId>

    <version>0.9.1</version>

  </dependency>

<!--注意：分页助手的插件 配置在通用馆mapper之前*-->*

<plugin interceptor="com.github.pagehelper.PageHelper">

<!—指定方言 —>

<property name="dialect" value="mysql"/>

</plugin>

 @Test

  public void testPageHelper() {

    //设置分页参数

    PageHelper.startPage(1, 2);

    List<User> select = userMapper2.select(null);

    for (User user : select) {

      System.out.println(user);

   }

 }

}

//其他分页的数据

PageInfo<User> pageInfo = new PageInfo<User>(select);

System.out.println("总条数："+pageInfo.getTotal());

System.out.println("总页数："+pageInfo. getPages ());

System.out.println("当前页："+pageInfo. getPageNum());

System.out.println("每页显万长度："+pageInfo.getPageSize());

System.out.println("是否第一页："+pageInfo.isIsFirstPage());

System.out.println("是否最后一页："+pageInfo.isIsLastPage());

<dependency>

<groupId>tk.mybatis</groupId>

<artifactId>mapper</artifactId>

<version>3.1.2</version>

</dependency>

<plugins>

<!--分页插件：如果有分页插件，要排在通用mapper之前-->

<plugin interceptor="com.github.pagehelper.PageHelper">

 <property name="dialect" value="mysql"/>

</plugin>

<plugin interceptor="tk.mybatis.mapper.mapperhelper.MapperInterceptor">

<!-- 通用Mapper接口，多个通用接口用逗号隔开 -->

<property name="mappers" value="tk.mybatis.mapper.common.Mapper"/>

</plugin>

</plugins>

@Table(name = "t_user")

public class User {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

private Integer id;

private String username;

}

import com.lagou.domain.User;

import tk.mybatis.mapper.common.Mapper;

public interface UserMapper extends Mapper<User> {

}

public class UserTest {

  @Test

  public void test1() throws IOException {

    Inputstream resourceAsStream =

Resources.getResourceAsStream("sqlMapConfig.xml");

    SqlSessionFactory build = new

SqlSessionFactoryBuilder().build(resourceAsStream);

    SqlSession sqlSession = build.openSession();

    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

    User user = new User();

    user.setId(4);

    //(1)mapper基础接口

    //select 接口

    User user1 = userMapper.selectOne(user); //根据实体中的属性进行查询，只能有 —个返回值

    List<User> users = userMapper.select(null); //查询全部结果

    userMapper.selectByPrimaryKey(1); //根据主键字段进行查询，方法参数必须包含完 整的主键属性，查询条件使用等号

    userMapper.selectCount(user); //根据实体中的属性查询总数，查询条件使用等号

    // insert 接口

    int insert = userMapper.insert(user); //保存一个实体，null值也会保存，不会使用数据库默认值

    int i = userMapper.insertSelective(user); //保存实体，null的属性不会保存， 会使用数据库默认值

    // update 接口

    int i1 = userMapper.updateByPrimaryKey(user);//根据主键更新实体全部字段，null值会被更新

    // delete 接口

    int delete = userMapper.delete(user); //根据实体属性作为条件进行删除，查询条件使用等号

    userMapper.deleteByPrimaryKey(1); //根据主键字段进行删除，方法参数必须包含完 整的主键属性

    //(2)example方法

    Example example = new Example(User.class);

    example.createCriteria().andEqualTo("id", 1);

    example.createCriteria().andLike("val", "1");

    //自定义查询

    List<User> users1 = userMapper.selectByExample(example);

 }

}