spring动态代理（jdk）

首先我们自己先写一个简单的Java代理，来看看其原理：

先建立一个Java项目：（我用的是idea所以操作有所不同，希望各位理解）

UserService接口：

/**
 * 接口类
 */
public interface UserService {
    /**
     * 查询所有用户信息
     */
    public void findUsers();
}```
TargetService目标类：

/**

• 目标类
  */

public class TargetService implements UserService {

   @Override
   public void findUsers() {
       System.out.println("目标：-------------输出用户信息");
   }
}

ProxyService代理类：

/**
 * 代理类
 */
public class ProxyService implements UserService {
    private  TargetService target;//要代理的目标类
    public ProxyService(TargetService target){
        this.target = target;
    }
    @Override
    public void findUsers() {
        System.out.println("代理类：--------------------开始事务");
        target.findUsers();
        System.out.println("代理类：--------------------提交事务");
    }
}

App（一个普通的带main方法的类）

public class App {
    public static void main(String[] args) {
        //创建目标
        TargetService target = new TargetService();
        //创建代理
        ProxyService proxy = new ProxyService(target);
        //执行代理方法
        proxy.findUsers();
    }
}

相信看了上面的简单案例，大家对代理有了一定的了解，下面来看一下spring的JDK动态代理

1、开发环境

jdk8.0+tomcat8.0+IDEA+MySql数据库

2、数据库结构

3、工程结构

在idea中建立maven工程sm_demo1，并进行如下配置：（idea中jar配置坐标后会自动下载，此处不多做解释）

1、工程配置：

2、配置说明

pom.xml:坐标配置
src：该目录下主要存放java代码，其中：
com.lmm.sm.bean：管理java实体类;
com.lmm.sm.dao：持久层代码管理，主要完成对数据库的CRUD;
com.lmm.sm.service：业务层代码管理，主要完成相关的业务处理；；
com.lmm.sm.test：一般用来进行单元测试；
resources：该目录下主要存放配置文件，其中有：
db.properties:配置数据库的driver、url、username、password

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

log4j.properties:配置框架日志输出

# Global logging configuration
# developer-->DEBUG productor-->INFO or ERROR
log4j.rootLogger=DEBUG, stdout
# MyBatis logging configuration...
6
log4j.logger.org.mybatis.example.BlogMapper=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

mybatis-config.xml:主要进行mybatis框架的配置，我们一般会配置别名、mapper映射等

<?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">
<!-- 这是mybatis的主配置文件，跟spring整合后，dataSources交给spring配置 文件管理 -->
<configuration>
    <!--配置基于bean目录的别名-->
    <typeAliases>
        <package name="com.lmm.sm.bean"/>
    </typeAliases>
    <!--配置基于dao目录的mapper映射-->
    <mappers>
        <package name="com.lmm.sm.dao"/>
    </mappers>

</configuration>

spring-bean.xml:spring框架配置文件，主要用来配置dataSource、sqlSessionFactory等

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启注解-->
    <context:annotation-config></context:annotation-config>
    <!--关联外部的db.properties文件-->
    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
    <!--配置数据源： 数据库连接池，两种方式，可以使用c3p0，这里我们使用的是dbcp -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="${jdbc.driver}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <property name="maxActive" value="10" />
        <property name="maxIdle" value="5" />
    </bean>
    <!-- 将mybatis中的写在代码中的sqlsessionfactory配置在 Spring配置文件中，交由spring管理，从而简化操作 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--数据库连接池-->
        <property name="dataSource" ref="dataSource"></property>
        <!--mybatis全局配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>
    </bean>
    <!-- 这里主要配置mapper扫描器，我们只需要在使用的时候通过 @AutoWired直接访问dao层的接口就行 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--配置dao层目录，主要是便于访问到具体的dao接口-->
        <property name="basePackage" value="com.lmm.sm.dao"></property>
        <!--配置sqlSessionFactory,主要是为了是框架内部生成SqlSession-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
    </bean>

    <!--将userService交给Spring管理,以包的形式配置-->
    <!--<bean id="userService" class="com.lmm.sm.service.impl.UserServiceImpl"></bean>-->
    <context:component-scan base-package="com.lmm.sm.service.impl"></context:component-scan>
</beans>

User.java

/**
 * 用户实体类
 */
public class User implements Serializable {
    private Integer id;
    private String username;
    private String sex;
    private Date birthday;
    private String address;

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", sex='" + sex + '\'' +
                ", birthday=" + birthday +
                ", address='" + address + '\'' +
                '}';
    }
}

UserDao

/**
 * dao层接口
 */
public interface UserDao {
    @Select("select *from user")
    @Results(
            id = "userMap",
            value = {
                    @Result(id = true,column = "id",property = "id"),
                    @Result(column = "username",property = "username"),
                    @Result(column = "sex",property = "sex"),
                    @Result(column = "birthday",property = "birthday"),
                    @Result(column = "address",property = "address")


            }
    )
    public List<User> findUsers();
}

UserServiceImpl

/**
 * service层实现类
 */
@Service("userService")//需要在spring-dao.xml中配置扫包等同于<bean id = "userService" calss = "com.lmm.sm.service.impl.UserServiceImpl">
public class UserServiceImpl implements UserService {
    @Autowired//需要在spring-dao.xml中配置相关信息，等同于<bean id = "userDao" class = "com.lmm.sm.dao.UserDaoImpl">
    private UserDao userDao;
    public List<User> findUsers() {
        return userDao.findUsers();
    }
}

UserService

/**
 * service层接口
 */
public interface UserService {
    /**
     * 查询所有用户信息
     * @return
     */
    public List<User> findUsers();
}

UserTest【使用jdk的代理实现】

public class UserTest {
   /**
     * 使用jdk的代理实现
     */
    @Test
    public void findUsers(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-bean.xml");
        //创建一个目标
        UserService target = (UserService) context.getBean("userService");
        //创建一个代理
        UserService proxy = (UserService) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),new MyProxy(target));
        //执行代理方法
        List<User> users =proxy.findUsers();
        System.out.println(users);
    }
    class MyProxy implements InvocationHandler{
        private UserService target;//目标
        public MyProxy(UserService target){
            this.target = target;
        }
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object obj = null;
            System.out.println("代理类---------------------------开始事务");
            //执行目标的方法(目标对象)
            obj = method.invoke(target,args);
            System.out.println("代理类---------------------------提交事务");
            return obj;
        }
    }
    }

UserTest中就是我们看到的jdk的动态代理实现，另外还有一个CGLIB的代理我们后面看时间可能会单独写一篇博文。