Spring框架是J2EE开发中一个使用广泛的框架，它使得dao和service层的维护更加便利。Spring框架有两个重要的特征，一个是IOC，另一个是AOP。我们在这里主要介绍IOC，以及IOC中涉及的主要技术。

　　IOC(Inversion Of Control)，控制反转是将创建对象的控制权从程序员手中转向Spring框架。Spring框架在创建对象时使用了DI技术。

　　DI（Dependency Injection），依赖注入主要是通过setter注入和构造器注入，产生一个类Class的bean（实例）。DI主要是通过动态代理和反射技术来实现的。

　　我们先来了解代理的概念。何为代理呢？顾名思义，代理可以帮助我们去完成某项事务，而且可以在完成事务中增强、完善相应的功能。举例来说，我国多个地区已经实施适龄公民可以直接报考驾照，但在实际中，我们在考取驾照时，往往会委托一家驾校帮助我们报考驾照，在这之中，驾校就充当了我们报考驾照的代理角色。显然，在很多时候，通过代理可以帮助我们节省时间，获得更加便捷的服务。

　　其实，我们在Java开发中运用代理，与生活中的代理概念相似。

,　　接下来，我们在介绍动态代理之前，先了解静态代理。我们接下来以生活中报考驾照为例写一个简单的案例，来了解静态代理。

　　

package bkjz;

/**

 * 考驾照的人

 */

public class Examiner {

    //身份证号,姓名

    private String id,name;

    public Examiner(String id, String name) {

        this.id = id;

        this.name = name;

    }

    @Override

    public String toString() {

        return "考生(姓名:" +name+

                ",身份证号:" + id + ")";

    }

}

******************

package bkjz;

/**

 * 考驾照,核心业务功能接口

 * 传递入一个具体报考驾照的人

 */

public interface GetDriverLicense {

    public void getDriverLicense(Examiner examiner);

}

******************

package bkjz.impl;

import bkjz.Examiner;

import bkjz.GetDriverLicense;

/**

 * 实现报考驾照的核心功能接口的类

 */

public class GetDriverLicenseImpl implements GetDriverLicense {

    @Override

    public void getDriverLicense(Examiner examiner) {

        System.out.println("报考驾照核心业务:您的各项报名指标合格,可以报考驾照");

    }

}

******************

package bkjz.impl;

import bkjz.Examiner;

import bkjz.GetDriverLicense;

/**

 * 驾校代理,帮助报考者报考驾照

 */

public class OrgProxy implements GetDriverLicense {

    //调用核心功能的接口实现类

    private GetDriverLicense getDriverLicense;

    //构造器传参

    public OrgProxy(GetDriverLicenseImpl getDriverLicense){

        this.getDriverLicense=getDriverLicense;

    }

    @Override

    public void getDriverLicense(Examiner examiner) {

        System.out.println("增强功能1:你好,"+examiner+",我来帮你收集报名需要提交哪些资料");

        System.out.println("增强功能2:你好,"+examiner+",我来帮你推荐体检医院,帮你节省时间");

        System.out.println("增强功能3:你好,"+examiner+",我来帮你到车管所递交报名资料,帮你节省时间");

        System.out.println("===========================");

        getDriverLicense.getDriverLicense(examiner);

        System.out.println("===========================");

        System.out.println("增强功能4:你好,"+examiner+",报名成功后,我帮你把报考所需身份资料的原件取回,帮你节省时间");

        System.out.println("增强功能5:你好,"+examiner+",我来帮你安排培训学习时间,帮你通过考试");

        System.out.println("增强功能6:你好,"+examiner+",你通过驾照考试后,我帮你邮寄驾照,帮你节省时间");

    }

}

*************************

package bkjz;

import bkjz.impl.GetDriverLicenseImpl;

import bkjz.impl.OrgProxy;

/**

 * 测试类

 */

public class Test {

    public static void main(String[] args) {

        //一个准备报考驾照的考生

        Examiner examiner=new Examiner("320923198901142757","张三");

        //找个驾校来报考驾照,以及安排后续的学习取照

        OrgProxy orgProxy=new OrgProxy(new GetDriverLicenseImpl());

        orgProxy.getDriverLicense(examiner);

    }

}

　　执行测试类后，运行结果如下：

增强功能1:你好,考生(姓名:张三,身份证号:320923198901142757),我来帮你收集报名需要提交哪些资料

增强功能2:你好,考生(姓名:张三,身份证号:320923198901142757),我来帮你推荐体检医院,帮你节省时间

增强功能3:你好,考生(姓名:张三,身份证号:320923198901142757),我来帮你到车管所递交报名资料,帮你节省时间

===========================

报考驾照核心业务:您的各项报名指标合格,可以报考驾照

===========================

增强功能4:你好,考生(姓名:张三,身份证号:320923198901142757),报名成功后,我帮你把报考所需身份资料的原件取回,帮你节省时间

增强功能5:你好,考生(姓名:张三,身份证号:320923198901142757),我来帮你安排培训学习时间,帮你通过考试

增强功能6:你好,考生(姓名:张三,身份证号:320923198901142757),你通过驾照考试后,我帮你邮寄驾照,帮你节省时间

　　可见，通过代理的确能够为我们带来很多便利，还可以增强很多功能。实际上，我们平时遇到的过滤器、拦截器从本质上来说，也是通过代理的方式实现的，通过代理增强一些功能，从而控制对被代理的业务的访问。当然，过滤器、拦截器运用的代理技术要比静态代理更灵活。

　　静态代理有个弊端，那就是如果具体业务改变时，我们需要改写其他的代理类，在需要代理的功能很多时，就会显著增加我们的工作量，不利于效率的提升。为此，我们引入动态代理的概念。

　　所谓动态代理，显然，我们需要增加一些增强型的功能时，不必再多次创建代理类，而是动态地进行相应的扩展即可。我们通过案例来看基于业务接口的动态代理。

package test2_proxy.proxy;

import test2_proxy.service.OrderServiceImpl;

import test2_proxy.service.UserServiceImpl;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

/**

 * 基于接口的动态代理

 * 对于一些需要重复执行的验证功能或下一步操作,

 * 在核心方法执行前后都会执行增强的功能

 */

public class ServiceProxy {

    public static Object newProxyInstance(Object target){

        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),new InvocationHandler() {

            @Override

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                System.out.println("动态增强功能1:登录权限认证");

                System.out.println("动态增强功能2:黑名单验证");

                System.out.println("=====================");

                Object invoke = method.invoke(target, args);//执行被代理的核心业务功能

                System.out.println("=====================");

                System.out.println("动态增强功能3:进入订单中心");

                System.out.println("此处省略一万行(●—●)...");

                return invoke;

            }

        });

    }

}

***********************

package test2_proxy.service;

/**

 * 用户登录、注册、找回密码等一系列服务的接口

 */

public interface UserService {

    public void testUserService();

}

************************

package test2_proxy.service;

import org.springframework.stereotype.Service;

/**

 * 实现用户服务接口的类

 */

@Service

public class UserServiceImpl implements UserService {

    @Override

    public void testUserService() {

        System.out.println("UserService核心功能");

    }

}

***************************

package test2_proxy.service;

/**

 * 订单服务接口，如下单、取消订单、放入购物车等

 */

public interface OrderService {

    public void testOrderService();

}

***************************

package test2_proxy.service;

/**

 * 实现订单核心功能接口的类

 */

public class OrderServiceImpl implements OrderService {

    @Override

    public void testOrderService() {

        System.out.println("OrderService核心功能");

    }

}

***************************

package test2_proxy;

import test2_proxy.proxy.ServiceProxy;

import test2_proxy.service.OrderService;

import test2_proxy.service.OrderServiceImpl;

import test2_proxy.service.UserService;

import test2_proxy.service.UserServiceImpl;

/**

 * 测试类

 */

public class Test {

    public static void main(String[] args) {

        UserService userService=new UserServiceImpl();

        userService = (UserService)ServiceProxy.newProxyInstance(userService);

        userService.testUserService();

        System.out.println("***************************");

        OrderService orderService=new OrderServiceImpl();

        orderService = (OrderService)ServiceProxy.newProxyInstance(orderService);

        orderService.testOrderService();

    }

}

　　上述代码执行完后，执行结果如下：

动态增强功能1:登录权限认证

动态增强功能2:黑名单验证

=====================

UserService核心功能

=====================

动态增强功能3:进入订单中心

此处省略一万行(●—●)...

***************************

动态增强功能1:登录权限认证

动态增强功能2:黑名单验证

=====================

OrderService核心功能

=====================

动态增强功能3:进入订单中心

此处省略一万行(●—●)...

　　可见，动态代理比静态代理更加灵活，它的核心是 java.lang.reflect.Proxy代理类，该类位于reflect反射包下，可知动态代理当中是用了反射的技术来实现的。

　　接下来，我们再看基于类实现的动态代理。此处需要在项目中添加 cglib-2.2.2.jar包的依赖，运用cglib的方法，使代码更简洁。我们通过案例来实现。

　　

package test3_proxy_cglib.proxy;

import net.sf.cglib.proxy.Enhancer;

import net.sf.cglib.proxy.MethodInterceptor;

import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

import java.util.Arrays;

/**

 * 动态代理类

 */

public class ServiceProxy {

    public static Object newProxyInstance(Object target) {

        //1.工具类

        Enhancer enhancer = new Enhancer();

        //2.设置父类,传递类对象

        enhancer.setSuperclass(target.getClass());

        //3.设置回调函数

        enhancer.setCallback(new MethodInterceptor() {

            @Override

            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

                System.out.println("cglib增强功能1");

                System.out.println("cglib增强功能2");

                System.out.println("此处省略一万行(●—●)...");

                System.out.println("==================");

                return method.invoke(target, objects);

            }

        });

        //4.功能增强后，返回代理对象

        return enhancer.create();

    }

}

****************************

package test3_proxy_cglib;

/**

 * 用户服务功能类

 */

public class UserService {

    public void testUserService(){

        System.out.println("UserService核心功能");

    }

}

*****************************

package test3_proxy_cglib;

/**

 * 订单服务功能类

 */

public class OrderService {

    public void testOrderService(){

        System.out.println("OrderService核心功能");

    }

}

**********************************

package test3_proxy_cglib;

import test3_proxy_cglib.proxy.ServiceProxy;

/**

 * 测试类

 */

public class Test {

    public static void main(String[] args) {

        UserService userService=new UserService();

        userService= (UserService)ServiceProxy.newProxyInstance(userService);

        userService.testUserService();

        System.out.println("***************************");

        OrderService orderService=new OrderService();

        orderService=(OrderService)ServiceProxy.newProxyInstance(orderService);

        orderService.testOrderService();

    }

}

　　上述代码的执行结果如下：

cglib增强功能1

cglib增强功能2

此处省略一万行(●—●)...

==================

UserService核心功能

***************************

cglib增强功能1

cglib增强功能2

此处省略一万行(●—●)...

==================

OrderService核心功能

　　接下来,我们看下反射。

　　Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。Java关于反射的定义主要在 java.lang.reflect包中。Java反射需要用到Class对象，Class对象的由来是将class文件读入内存，并为之创建一个Class对象。

　　Class 类的实例表示正在运行的 Java 应用程序中的类和接口,也就是jvm中有N多的实例，每个类都有对应的Class对象（包括基本数据类型）。Class 没有公共构造方法，Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineClass 方法自动构造的。也就是说，Class 对象不需要我们自己去创建，JVM已经帮我们创建好了。

　　在使用反射时，我们需要先获取Class对象。获取Class对象有三种方式：

　　第一，Object对象.getClass()

　　第二，任何数据类型（包括基本数据类型）都有一个静态static的class属性

　　第三，通过Class类的静态方法forName(String className)来获取  Class.forName(String className)    ------>[这是我们常用的获取类对象的方法]

　　需要注意的是，在程序运行期间，一个类只有一个Class对象产生，该Class对象由JVM管理。获得了类对象，我们就随之可以使用这个类对象的所有属性和方法。

　　通过反射，我们可以获取一个类的任意方法（包括构造方法）和属性，从而充分利用一个类所提供的一切资源。

　　另外，我们在使用各类集合（如List，Set，Map）时，为了指明集合中元素的类型，通常会用到泛型，泛型是作用于程序编译期，编译过后，泛型的约束就会失效；反射则作用于程序编译期之后的运行期，因此，我们可以通过反射来越过泛型的检查。我们通过下面的案例来看：　　

package test9;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.List;

/**

 * 泛型作用于编译期,会在编译之前对程序进行检查

 * 编译期过后,泛型约束失效

 * 反射作用于运行期

 * 演示通过反射越过泛型的检查

 */

public class Test {

    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {

        //1.先声明一个List集合,元素泛型约束为String类型

        List<String> strList=new ArrayList<>();

        //2.向集合中添加String型的元素

        strList.add("aa");

        strList.add("bb");

        //注:在编译期之前,向集合中添加非泛型元素,程序会在编译期就报错

        //strList.add(123);

        //这时,我们通过反射来越过泛型检查

        Class strListClass = strList.getClass();//先获取Class对象

        //获取add方法,为了保障程序清晰,在main方法上抛出异常

        Method method = strListClass.getMethod("add", Object.class);

        //通过反射调用add方法,添加一个int型数据

        method.invoke(strList,123);

        System.out.println("strList="+strList);

    }

}

　　上述代码打印结果如下：

strList=[aa, bb, 123]

　　可见，定义元素泛型为String的List集合成功越过了泛型检查，添加了一个int型数据。

最新文章

  1. 2016/12/30_Python
  2. 7Hibernate高级----青软S2SH(笔记)
  3. JS 初级（三）接上
  4. linux修改主机名的方法
  5. FFmpeg 2.1 发布
  6. asp.net identity 2.2.0 中角色启用和基本使用（四）
  7. Ajax风格的一款网页Loading效果
  8. Mybatis foreach
  9. DOS删除服务
  10. Highcharts Pie 饼图提示标签IE下重叠解决方法，及json数据绑定方法
  11. windows cmd: 增强windows命令行
  12. hihocoder1257(构造)(2015北京ACM/ICPC)
  13. 使用gogs搭建git私有仓库
  14. Fiddler使用~知多少?
  15. 列表生成式，迭代器&amp;生成器
  16. c#Dapper mysql按时间段查询和过滤
  17. 2018项目UML设计-课堂实战
  18. 最全的MonkeyRunner自动化测试从入门到精通（9）
  19. HTML的day1 HTML的标签
  20. Jenkins进阶-邮件通知(9)

热门文章

  1. Cells UVALive - 3486（dfs序+手动开栈）
  2. 创建Django工程-Day19
  3. BZOJ1563/洛谷P1912 诗人小G 【四边形不等式优化dp】
  4. syntax error: non-declaration statement outside function body
  5. The 14th Zhejiang Provincial Collegiate Programming Contest Sponsored by TuSimple - C 暴力 STL
  6. Codeforces 895.E Eyes Closed
  7. Python基础之面向对象（进阶篇）
  8. input file 图片上传展示重新上传
  9. Eclipse中使用Maven创建项目 (转)
  10. 莫队+分块 BZOJ 3809