4、MyBatis + Log4j日志查看Sql参数、结果集元数据、Mapper代理开发、JDK的动态代理与CGLib代理

最新推荐文章于 2023-01-11 18:15:07 发布
最新推荐文章于 2023-01-11 18:15:07 发布
阅读量426 收藏
点赞数
分类专栏： SSM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ShawnYue_08/article/details/108423181
版权

文章目录

MyBatis优化开发

日志

MyBatis在执行过程中的信息显示，尤其是SQL参数。

1、增加依赖

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

2、增加核心配置文件 .properties .xml

#USE THIS SETTING FOR OUTPUT MYBATIS`s SQL ON THE CONSOLE
log4j.rootLogger=debug, Console,E
#Console
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
#log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
log4j.appender.Console.layout.ConversionPattern=[ %l ] %d{yyyy/MM/dd HH:mm:ss}%-5p [%c{1}] - %l - %m%n
### \u4FDD\u5B58\u5F02\u5E38\u4FE1\u606F\u5230\u5355\u72EC\u6587\u4EF6 ###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File = error.log
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ]- [ %p ] %m%n

3、测试mybatis-01中的代码

${value} 测试Integer类型

在这里插入图片描述

#{aname} 测试String类型，#{}会根据参数的类型自动选择是否添加单引号，而${}不会

在这里插入图片描述

ResultSet如何转换为Java对象

ResultSet结果集元数据 + 反射

数据库元数据

package org.westos.util;

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.SQLException;

/**
 * 数据库元数据
 * @author lwj
 * @date 2020/9/5 10:44
 */
public class DataBaseMetaDataDemo {
    public void show() throws ClassNotFoundException, SQLException {
        Class.forName("com.mysql.jdbc.Driver");
        Connection connection = DriverManager.getConnection("jdbc:mysql:///mybatis?useSSL=false",
                "root", "995995zxvc");
        DatabaseMetaData metaData = connection.getMetaData();
        //数据库元数据由Connection连接对象获取
        String databaseProductName = metaData.getDatabaseProductName();
        //数据库产品名称
        String databaseProductVersion = metaData.getDatabaseProductVersion();
        //数据库产品版本
        String driverName = metaData.getDriverName();
        //驱动名称
        String driverVersion = metaData.getDriverVersion();
        //驱动版本
        int defaultTransactionIsolation = metaData.getDefaultTransactionIsolation();
        //默认事务隔离级别
        System.out.println(databaseProductName);
        System.out.println(databaseProductVersion);
        System.out.println(driverName);
        System.out.println(driverVersion);
        System.out.println(defaultTransactionIsolation);
    }
}

测试

package org.westos.util;

import org.junit.Test;

import java.sql.SQLException;

/**
 * @author lwj
 * @date 2020/9/5 11:46
 */
public class DataBaseMetaDataTest {
    @Test
    public void test() throws SQLException, ClassNotFoundException {
        DataBaseMetaDataDemo dataBaseMetaDataDemo = new DataBaseMetaDataDemo();
        dataBaseMetaDataDemo.show();
    }
}

在这里插入图片描述

结果集元数据

ResultSet封装为Java对象 = 结果集元数据 + 反射

package org.westos.util;


import org.westos.model.Account;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
 * ResultSet封装为Java对象
 * @author lwj
 * @date 2020/9/5 10:43
 */
public class ResultSetMetaDemo<T> {
    public List<T> transferToObject(Class<T> clazz, ResultSet resultSet) {
        List<T> list = null;
        try {
            if (resultSet != null) {
                ResultSetMetaData metaData = resultSet.getMetaData();
                Method[] declaredMethods = clazz.getDeclaredMethods();
                while (resultSet.next()) {
                    T obj = clazz.newInstance();
                    for (int i = 1; i <= metaData.getColumnCount(); i++) {
                        Object object = resultSet.getObject(i);
                        String columnLabel = metaData.getColumnLabel(i);
                        for (Method declaredMethod : declaredMethods) {
                            if (declaredMethod.getName().toUpperCase().equals(("set" + columnLabel).toUpperCase())) {
                                declaredMethod.invoke(obj, object);
                            }
                        }
                    }
                    if (list == null) {
                        list = new ArrayList<>();
                    }
                    list.add(obj);
                }
            } else {
                return null;
            }
        } catch (SQLException | IllegalAccessException | InstantiationException | InvocationTargetException e) {
            e.printStackTrace();
        }
        return list;
    }
}

Fastjson

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.73</version>
</dependency>

美化输出Java对象。

package org.westos.util;

import com.alibaba.fastjson.JSON;
import org.junit.Test;
import org.westos.model.Account;

import java.sql.*;
import java.util.List;

/**
 * @author lwj
 * @date 2020/9/5 10:55
 */
public class ResultSetMetaTest {
    @Test
    public void test() throws ClassNotFoundException, SQLException {
        Class.forName("com.mysql.jdbc.Driver");
        Connection connection = DriverManager.getConnection("jdbc:mysql:///mybatis?useSSL=false", "root", "995995zxvc");
        PreparedStatement preparedStatement = connection.prepareStatement("select aid, aname, apassword, a_nickname anickname from account");
        ResultSet resultSet = preparedStatement.executeQuery();

        List<Account> list = new ResultSetMetaDemo<Account>().transferToObject(Account.class, resultSet);
        //System.out.println(list); 原生List输出显示效果不好，这里使用fastjson输出
        //首先导入依赖
        System.out.println(JSON.toJSONString(list, true));
        //JSON.toJSONString(Object obj, boolean prettyFormat) 美化格式
    }
}

[
	{
		"aid":1,
		"aname":"zhangsan",
		"anickname":"张三",
		"apassword":"nasgnahz"
	},
	{
		"aid":2,
		"aname":"lisi",
		"anickname":"李四",
		"apassword":"isil"
	},
	{
		"aid":3,
		"aname":"wangwu",
		"anickname":"王五",
		"apassword":"uwgnaw"
	},
	{
		"aid":4,
		"aname":"john",
		"anickname":"jj",
		"apassword":"123456"
	},
	{
		"aid":5,
		"aname":"jack",
		"anickname":"kk",
		"apassword":"123456"
	},
	{
		"aid":6,
		"aname":"cef4cf5e-ee6b-11ea-8661-98fa9b26cec1",
		"anickname":"kk",
		"apassword":"123456"
	}
]

基于MyBatis的DAO开发（传统）

在上一篇博客中，其实已经写了传统DAO开发的步骤，现在可以在写一次，发现它的问题。

提供一个工具类，保证SqlSessionFactory全局唯一。

package org.westos.util;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

/**
 * MyBatis工具类为Mapper提供
 * @author lwj
 * @date 2020/9/3 19:43
 */
public class SqlSessionFactoryUtil {
    private volatile static SqlSessionFactory factory;
    //volatile，禁止指令重排序，主要是new对象的操作

    private static final String CONFIG_FILE_NAME = "mybatis-config.xml";

    private SqlSessionFactoryUtil() {

    }

    /**
     * 保证SqlSessionFactory是系统唯一的
     * @return SqlSessionFactory
     */
    public static SqlSessionFactory getSqlSessionFactory() {
        if (factory == null) {
            synchronized (SqlSessionFactoryUtil.class) {
                if (factory == null) {
                    try {
                        InputStream in = Resources.getResourceAsStream(CONFIG_FILE_NAME);
                        factory = new SqlSessionFactoryBuilder().build(in);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        return factory;
    }
}

实际开发中，我们应该有DAO类，封装CRUD方法。我们现在可以利用MyBatis提供的编程接口来代替JavaWeb阶段的方法。在MyBatis中DAO用Mapper类代替。

AccountMapper.java

package org.westos.mapper;

import org.apache.ibatis.session.SqlSession;
import org.westos.model.Account;
import org.westos.util.SqlSessionFactoryUtil;

import java.util.List;

/**
 * @author lwj
 * @date 2020/9/3 20:05
 */
public class AccountMapper {
    public List<Account> queryAll() {
        SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession();
        try {
            return sqlSession.selectList("org.westos.mapper.AccountMapper.queryAll");
        } finally {
            sqlSession.close();
        }
    }

    public Account queryOne(Integer aid) {
        try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
            return sqlSession.selectOne("org.westos.mapper.AccountMapper.queryOne", aid);
        }
    }

    public Account queryByName(String name) {
        try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
            return sqlSession.selectOne("org.westos.mapper.AccountMapper.queryByName", name);
        }
    }

    //模糊查询
    public List<Account> selectByName(String name) {
        try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
            return sqlSession.selectList("org.westos.mapper.AccountMapper.selectByName2", name);
        }
    }

    public void insert(Account account) {
        try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
            sqlSession.insert("org.westos.mapper.AccountMapper.insert2", account);
            sqlSession.commit();
        }
    }

    public void update(Account account) {
        try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
            sqlSession.update("org.westos.mapper.AccountMapper.update", account);
            sqlSession.commit();
        }
    }

    public void delete(int aid) {
        try (SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession()) {
            sqlSession.delete("org.westos.mapper.AccountMapper.delete", aid);
            sqlSession.commit();
        }
    }
}

可以看出，以上很多代码是冗余的，在代码中嵌入了大量的sql ID。

那么有没有一种方法，可以将Mapper接口与mapper.xml进行对应，而避免编写Mapper接口的实现类，从而避免去关联mapper.xml中的namespace + id。

其实是可以的，只要遵循几个规则：

  • 文件名（AccountMapper.java、AccountMapper.xml）
  • 方法名
  • 参数
  • 返回值
  • 接口全路径，对应mapper.xml的namespace

如果一一对应了，那Mapper实现类还有存在的必要吗？

没有了，因为我们可以JDK动态代理（JDK的动态代理—只可以代理接口），生成接口的代理类。（基于接口的代理）

推荐mapper代理开发

我们只需要编写mapper接口和mapper.xml映射文件。

mybatis框架下mapper接口与对应xml文件之间的互相跳转，下载插件：

Free MyBatis Plugin

Mapper代理开发注意事项，必须严格遵循：

  • mapper.xml中的namespace必须和接口的全路径保持一致【因为mybatis要为接口动态产生代理
    对象，当执行接口中的方法，代理对象就会查找对应的mapper文件，mapper文件与接口如何对应
    呢？就需要namaspace】
  • mapper中的方法名id必须和接口中的方法名保持一致
  • 因为接口中的方法是可以被重载的，所以mapper中的sql id 对应的返回值类型，和参数类型需要
    与接口中保持一致。接口中如果返回值是集合，xml中还是集合中元素的数据类型，（接口中的方法可以重载，但是xml文件不可以重载）
  • 一定要将mapper接口【注册】交给mybaits
<mappers>
    <!--<mapper class="org.westos.mapper.AccountMapper"/>-->
    <!--注意：当配置的mapper属性为resources时，后面是/，当mapper属性为class时，后面是.-->

    <!--当我们需要配置多个mapper时，可以使用包扫描-->
    <package name="org.westos.mapper"/>
</mappers>

开发步骤：

1、AccountMapper.java接口

package org.westos.mapper;

import org.westos.model.Account;

import java.util.List;

/**
 * @author lwj
 * @date 2020/9/5 14:00
 */
public interface AccountMapper {
    List<Account> queryAllAccount();

    Account queryByPrimaryId(Integer aid);

    Account queryAccountByName(String name);

    void insertAccount(Account account);

    void updateAccount(Account account);

    void deleteAccountById(Integer aid);
}

2、AccountMapper.xml映射文件

<?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="org.westos.mapper.AccountMapper">
    <select id="queryAllAccount" resultType="Account">
        select aid, aname, apassword, a_nickname as anickname
        from account
    </select>

    <select id="queryByPrimaryId" resultType="Account">
        select aid, aname, apassword, a_nickname as anickname
        from account
        where aid = #{aid}
    </select>

    <select id="queryAccountByName" resultType="Account">
        select aid, aname, apassword, a_nickname as anickname
        from account
        where aname like #{aname}
    </select>

    <insert id="insertAccount">
        insert into
        account(aname, apassword, a_nickname)
        values (#{aname}, #{apassword}, #{anickname})
    </insert>

    <update id="updateAccount" parameterType="java.lang.Integer">
        update account
        set aname = #{aname}, apassword = #{apassword}, a_nickname = #{anickname}
        where aid = #{aid}
    </update>

    <delete id="deleteAccountById" parameterType="java.lang.Integer">
        delete from account
        where aid = #{aid}
    </delete>
</mapper>

3、测试

package org.westos.mapper;

import com.alibaba.fastjson.JSON;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import org.westos.model.Account;
import org.westos.util.SqlSessionFactoryUtil;

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

/**
 * @author lwj
 * @date 2020/9/5 14:04
 */
public class AccountMapperTest {
    @Test
    public void queryAll() throws IOException {
        SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession();
        AccountMapper mapper = sqlSession.getMapper(AccountMapper.class);
        List<Account> list = mapper.queryAllAccount();
        System.out.println(JSON.toJSONString(list, true));
    }

    @Test
    public void queryByPrimaryId() throws IOException {
        SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactory().openSession();
        AccountMapper mapper = sqlSession.getMapper(AccountMapper.class);
        Account account = mapper.queryByPrimaryId(1);
        System.out.println(JSON.toJSONString(account, true));
    }

    //增删改 提交事务sqlSession.commit()
}

在这里插入图片描述

JDK动态代理

在SE阶段学了JDK的动态代理，现在在MyBatis阶段，再给出JDK动态代理的方式。

JDK动态代理及分析

代理设计模式：

程序：完成一个业务，有核心业务和非核心业务之分。所谓代理设计模式，就是将核心业务与非核心业务相分离。

代理的本质就是将核心业务与非核心业务分离，代码容易维护，减少冗余，让程序具有更高的扩展性。

代理设计模式中的几个概念：

  • 目标角色：target 被代理者 （卖房者）
  • 代理角色：paoxy 代理角色 （中介）
  • 抽象角色：是指目标和代理的共同约束
  • 客户端：调用者
抽象角色 js = new 代理角色(目标角色);
js.xxx();
//调用方法后，代理角色方法就会执行

代理的Java实现

  • 静态代理
    • 有一个目标类，就要写一个代理类，类过多，繁琐
  • 动态代理
    • 基于接口的Proxy，要求被代理类和目标类都要实现接口
package org.westos.service;

import org.westos.model.Account;

/**
 * @author lwj
 * @date 2020/9/7 8:14
 */
public interface IAccountService {
    void register(Account account);

    void show();
}

package org.westos.service;

import org.westos.model.Account;

/**
 * @author lwj
 * @date 2020/9/5 17:39
 */
public class AccountService implements IAccountService{
    @Override
    public void register(Account account) {
        System.out.println("AccountService要保存数据了");
    }

    @Override
    public void show() {
        System.out.println("AccountService查询数据并展示");
    }
}

package org.westos.service;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author lwj
 * @date 2020/9/5 17:20
 */
public class ProxyUtil implements InvocationHandler {
    private Object obj;
    //被代理类对象

    public ProxyUtil(Object obj) {
        this.obj = obj;
    }

    public Object getProxy() {
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),
                this);
        //第三个参数为InvocationHandler接口的实现类对象
    }

    /**
     * 当访问被代理类的方法时，程序来到该invoke()方法处
     * @param proxy 代理对象
     * @param method 方法对象
     * @param args 方法的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        //动态代理，来增强被代理类的方法逻辑
        long start = System.currentTimeMillis();
        System.out.println("===" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())
                + "正在访问" + method + "===");
        result = method.invoke(obj, args);
        //调用目标类的方法
        long end = System.currentTimeMillis();
        System.out.println("程序耗时" + (end - start) / 1000 + "s.");
        return result;
    }
}

测试：

package org.westos.service;

import org.junit.Test;

/**
 * @author lwj
 * @date 2020/9/7 8:16
 */
public class ProxyTest {
    @Test
    public void testProxy() {
        AccountService accountService = new AccountService();
        IAccountService service = (IAccountService) new ProxyUtil(accountService).getProxy();
        service.register(null);
        service.show();
        //===2020-09-07 08:21:06正在访问public abstract void org.westos.service.IAccountService.register(org.westos.model.Account)===
        //AccountService要保存数据了
        //程序耗时0s.
        //===2020-09-07 08:21:06正在访问public abstract void org.westos.service.IAccountService.show()===
        //AccountService查询数据并展示
        //程序耗时0s.
    }
}

JDK生成的动态代理类：

  • extends Proxy类，implements 被代理类实现的接口；
  • 正是由于Java不支持多继承，所以动态代理类已经继承了Proxy类，则不能则继承其他类，所以JDK的动态代理只能代理接口，而不能代理类；

JDK动态代理是基于接口的方式，换句话来说就是代理类和目标类都实现同一个接口，那么代理类和目标类的方法名就一样了。

CGLib代理

JDK的动态代理，只能用来代理接口。

而使用cglib可以代理类。（基于类的动态代理）

CGLib动态代理是代理类去继承目标类，然后重写其中目标类的方法，这样也可以保证代理类拥有目标类的同名方法。（CGLib无法代理final的方法）

1、引入依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

2、在JDK动态代理中提供一个Proxy类来创建代理类，而在CGLib动态代理中也提供了一个类似的类Enhancer（增强）；

3、MethodInterceptor：方法拦截器

package org.westos.service;

import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import net.sf.cglib.reflect.FastClass;

import java.lang.reflect.Method;

/**
 * @author lwj
 * @date 2020/9/5 17:41
 */
public class ProxyCGLibUtil implements Callback {
    private Object obj;
    //目标类对象

    public ProxyCGLibUtil(Object obj) {
        this.obj = obj;
    }

    public Object getProxy() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(obj.getClass());
        //代理类要继承obj的类
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                //o表示代理对象，method表示目标类中的方法，args表示方法参数，proxy表示代理方法的MethodProxy对象
                return methodProxy.invokeSuper(o, objects);
            }
        });
        return enhancer.create();
        //生成动态代理类
    }
}

4、测试

package org.westos.service;

import net.sf.cglib.core.DebuggingClassWriter;
import org.junit.Test;
import org.westos.model.Account;

/**
 * @author lwj
 * @date 2020/9/5 18:00
 */
public class ProxyCGLibTest {
    @Test
    public void test() {
        AccountService accountService = new AccountService();
        AccountService service = (AccountService) new ProxyCGLibUtil(accountService).getProxy();
        System.out.println(service);
        //org.westos.service.AccountService$$EnhancerByCGLIB$$f91ee6ca@33a10788
        service.register(new Account());
        service.show();
        //AccountService要保存数据了
        //AccountService查询数据并展示
    }
}

生成CGLib动态代理生成的代理类的class文件。

package org.westos.service;

import net.sf.cglib.core.DebuggingClassWriter;
import org.junit.Test;
import org.westos.model.Account;

/**
 * @author lwj
 * @date 2020/9/5 18:00
 */
public class ProxyCGLibTest {
    @Test
    public void test() {
        //在指定目录下生成动态代理类
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "E:\\XiBuKaiYuan\\SSM\\mybatis\\mybatis-02\\target\\classes\\org\\westos\\service");

        ProxyCGLibUtil proxyCGLibUtil = new ProxyCGLibUtil(new AccountService());
        AccountService accountService = (AccountService) proxyCGLibUtil.getProxy();
        System.out.println(accountService.getClass().getName());
        //org.westos.service.AccountService$$EnhancerByCGLIB$$f91ee6ca
        accountService.register(new Account());
        accountService.show();
    }
}

在这里插入图片描述

我们指定的目录下面看一下生成的字节码文件，有三个，一个是代理类的FastClass，一个是代理类，一个是目标类的FastClass，

中间那个是代理类，第一个是代理类的FastClass，第三个是目标类的FastClass。

package org.westos.service;

import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import org.westos.model.Account;

public class AccountService$$EnhancerByCGLIB$$f91ee6ca extends AccountService implements Factory {
    //......
    
    //重写父类的方法
    @Override
    public final void register(Account var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$register$0$Method, new Object[]{var1}, CGLIB$register$0$Proxy);
        } else {
            super.register(var1);
        }
    }
    
    @Override
    public final void show() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$show$1$Method, CGLIB$emptyArgs, CGLIB$show$1$Proxy);
        } else {
            super.show();
        }
    }
    
    //equals()、hashCode()、toString()、clone()
    
    final void CGLIB$register$0(Account var1) {
        super.register(var1);
    }
    
    final void CGLIB$show$1() {
        super.show();
    }
    
    final boolean CGLIB$equals$2(Object var1) {
        return super.equals(var1);
    }
    //hashCode、toString、clone
    
    //newInstance()、set/getCallback

Jdk动态代理的拦截对象是通过反射的机制来调用被拦截方法的，反射的效率比较低，所以cglib采用了FastClass的机制来实现对被拦截方法的调用。
FastClass机制就是对一个类的方法建立索引，通过索引来直接调用相应的方法。

ShawnYue_08
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis代理开发
07-21
Mybatis通过动态代理（JDK Proxy或CGLIB）创建Mapper接口的实现类，这个实现类在运行时动态生成，包含了执行SQL的方法。当我们调用Mapper接口的方法时，实际上是在调用这个动态生成的实现类的方法，从而完成SQL的...
springboot日志，log4j加mybatis配置显示sql
焱敦的博客
08-23 1266
log4j加mybatis配置显示sql信息
使用log4jdbc记录SQL信息
evilcry2012的专栏
11-21 379
孤傲苍狼 只为成功找方法，不为失败找借口！ 使用log4jdbc记录SQL信息 一、log4jdbc的简单介绍 　　使用log4jdbc在不改变原有代码的情况下，就可以收集执行的SQL文和JDBC执行情况。 　　平时开发使用的ibatis,hibernate,spring jdbc的sql日志信息，有一点个缺点是占位符与参数是分开打印的,如果想要拷贝sql至PLS
使用log4jdbc输出sql操作
exlinker的博客
09-19 1004
文章目录前言特性配置依赖配置 application添加 log4jdbc.log4j2.properties添加 logback.xml 前言 log4jdbc 是一个 JDBC 驱动器，能够记录 SQL 日志和 SQL 执行时间等信息。log4jdbc 使用 SLF4J（Simple Logging Facade）作为日志系统。 特性 支持 JDBC3 和 JDBC4 。 支持现有大部分 JDBC 驱动。 易于配置（在大部分情况下，只需要改变驱动类名并在 jdbc url 中加上:log4jdbc，设
log4jdbc实现慢查询sql记录
每一次对问题的深究，总会收获新的知识和体会
06-16 6385
首先，明确一个概念，这个也是之前一直没怎么搞清楚的：     log4jdbc一共有三个分支，log4jdbc是原版，最近终于加入Maven的主仓库中，fork之一是log4jdbc-remix，后来又再fork了一个log4jdbc-log4j2。 原版Log4jdbc：https://code.google.com/p/log4jdbc/ Slf4jSpyLogDelegator DriverSpy log4jdbc.sqltiming.warn.threshold log4jdbc.sqltimin
mybatis参数配置和日志详解~
m0_64365419的博客
01-11 2787
SqlSessionFactory的实例可以通过 SqlSessionFactoryBuilder 获得，而 SqlSessionFactoryBuilder则可以从XML配置文件或一个预先配置的 Configuration实例来构建出SqlSessionFactory实例。
Spring框架,AOP,Spring整合Mybatis
01-13
Java提供了两种动态代理实现：JDK动态代理和CGLIB。JDK动态代理基于接口，当目标对象实现了至少一个接口时，Java反射API可以动态生成实现了这些接口的代理类。而CGLIB（Code Generation Library）是在运行期通过字节...
详解Mybatis（五）Mapper接口
08-26
Mapper接口的原理是基于动态代理的技术，Mybatis使用JDK的代理机制或CGLib来生成代理对象，从而实现Mapper接口的方法调用。这种机制使得开发者可以使用接口来编写数据库操作的代码，而不需要关心底层的实现细节。 ...
深入浅出MyBatis技术原理与实战 第六章 源代码
07-30
MyBatis使用JDK的动态代理或者CGLIB来实现Mapper接口的代理类，这样在调用Mapper方法时，实际上执行的是动态生成的代理类的方法，从而实现了SQL的动态编织。动态代理是MyBatis实现方法拦截、事务管理和结果映射的...
mybatis项目源码学习
最新发布
06-18
MyBatis 使用 JDK 动态代理或者 CGLIB 生成 Mapper 接口的代理对象，使得调用方法时能直接执行对应的 SQL 语句。 以上就是 MyBatis 框架中涉及的主要知识点。通过对 MyBatis 的源码学习，你可以深入理解其工作原理...
mybatis配置log4j日志输出sql文及sql参数和结果集
忧伤的可乐鸡
02-10 9557
因为不是CSDN的博客，特意收藏过来，感谢原作者提供解决方案。亲测好用！ 这里分享下我的实践。 简单讲就两步， 第一步配置log4j # 打印sql语句:debug; 执行结果:trace ## 指定mapper配置文件中的namespace log4j.logger.com.exam.dao =TRACE （log4j.logger.包名）原因是mybatis设置日志打印级别为TR
MyBatis三种基本查询方法与log4j
qq_41177704的博客
11-18 142
selectList 查询不到时，返回空list。可以通过list.size()判断是否查询到。 List<User> list = sqlSession.selectList("selAll"); 源码 @Override public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { try { MappedStatement ms = co
反射和代理以及Mapper中的应用
weixin_44715126的博客
07-06 998
java中的反射和代理， 反射和代理在Mybatis Mapper中的使用
mybatis中log4j的使用(控制台查看sql执行结果)
Distance的博客
08-15 1421
第一步（在项目中导入log4j的包） 第二步（在src下创建log4j.properties）要求文件名必须是log4j.properties也必须在src下 源码 源码 log4j.rootCategory=ERROR, CONSOLE ,LOGFILE log4j.logger.com.wb.mapper.People=DEBUG log4j.appender.CONSOLE=or...
3）Mybatis日志框架
jaemy2011的博客
06-05 2317
mybatis日志框架原码分析
使用Log4j2打印Mybatis SQL语句以及结果集
weixin_34227447的博客
01-05 3257
为什么80%的码农都做不了架构师？>>> ...
Mybatis查询结果和sql语句
weixin_43907181的博客
06-07 254
Mybatis 配置的xml文件：mybatis-config.xml <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <!-- 别名，自动扫描com.how2java.po
mybatis配置输出执行sql日志
热门推荐
blood_Z的博客
03-24 1万+
配置日志打印sql 方式一,设置mybatis日志输出类## 标题 #输出查询结果 mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl #不输出查询结果 #mybatis.configuration.log-impl=org.apache.ibatis.logging.log4j2.Log4j2Impl 方式二，设置mapper接口日志等级为debug logging.level.com.xxx.xxx.da
maven+spring+springmvc+mybatis+log4j +oracle
11-11
Maven是一个用于管理Java项目构建、依赖管理和项目报告的工具，可以简化项目的构建过程。Spring是一个开源的Java应用程序框架，用于构建企业级应用程序，提供了依赖注入、面向切面编程等功能。Spring MVC是Spring框架的一部分，用于构建基于模型-视图-控制器的Web应用程序。MyBatis是一个持久层框架，利用SQL映射文件配置，可以方便地进行数据库操作。Log4j是一个用于记录日志的Java库，可以对日志进行分级、过滤和输出到不同的目标。 Oracle是一个关系型数据库管理系统，被广泛应用于企业级应用程序的开发中。当这些技术结合在一起时，可以构建一个完整的企业级Java应用程序。Maven可以管理项目的依赖，可以方便地引入Spring、Spring MVC、MyBatis和Log4j等框架，并且可以统一管理这些框架的版本和配置。Spring提供了依赖注入和面向切面编程的功能，可以简化项目的开发，并且能够与Spring MVC无缝集成，提供Web应用程序的开发支持。MyBatis可以方便地进行数据库操作，而Log4j则可以记录应用程序的日志，方便开发人员进行排错和监控。而Oracle作为一个可靠的数据库系统，可以作为应用程序的持久化存储。 总之，这些技术的结合可以构建一个高效、稳定的企业级Java应用程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值