前言
Spring的核心=IOC+AOP
- IOC 为Inversion of Control的缩写,意为:控制反转=接口+工厂模式实现调用方和被调用方之间的解耦合
- AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,底层是动态代理
一、接口+工厂模式解耦合
如何设计低耦合、易复用的软件,面向接口+工厂模式是不错的选择;
1.面向接口编程思想
为什么在MVC三层架构中service层一定要定义接口呢?web层直接调用service实现类不好吗?
1.1.什么是耦合?
在1个系统系统架构中,各个组件之间的耦合是不可避免的。
耦合就是依赖,B依赖A的方法才能执行。
1.2.面向接口编程的流程?
在程序开发之前预先定义接口,接口中定义方法;
强制被调用方按照接口中定义的方法开发实现类;
调用方在调用被调用方时只关注接口(中间层)中定义的方法即可,被调用方修改了接口的实现类逻辑,也不会影响调用方调用;
例如:在web层(调用方)和service层(被调用方)之间定义接口层;
1.3.面向接口编程的目的
面向接口编程实现了低耦合,但是没有完全解开耦合;
我们需要借助面向接口编程+工厂模式,继续解开耦合 ;
2.接口+工厂模式
使用接口+工厂模式可以解开程序编译阶段的耦合,实现程序高内聚和低耦合。
2.1.Java程序执行流程
Java程序分为编译和运行阶段;
- 编译(开发)阶段耦合:是可以解开的
- 运行阶段耦合: 是无法避免的不可以解开的
2.2.解编译阶段的耦合
程序之间的耦合是不可避免的,借助面向接口编程+工厂模式:
- 可以实现程序编译阶段的耦合,
- 无法实现程序运行阶段的耦合;
2.3.编译阶段耦合解开代码体现
使用接口+工厂模式解耦合(编译阶段耦合解开)的代码体现是
- 调用方在调用被调用方时,无需调用方new而是通过给工厂类传递被调用方的对象参数,工厂类接收到对象参数,由工厂类创建被调用方的实现类对象,实现程序的高内聚和低耦合;
- 即使注释/删除被调用方的代码
- 调用方调用被调用方法的代码,程序在编译阶段也不会报错;
2.4.实现流程分析
调用方和被调用方之间增加工厂类
实现工厂类
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.itheima.factory; import java.util.ResourceBundle; //创建service层(serviceImp)对象的工厂 public class BeanFactory { private static Object bean = null; public static Object getBean(String beanId) { try { //1.读取配置文件 ResourceBundle resourceBundle = ResourceBundle.getBundle("beans"); //2.从配置文件中根据beanId获取到类的全限定名称 String stringClassName = resourceBundle.getString(beanId); //3.根据上一步获取到的类权限定名称创建对象 Class aClass = java.lang.Class.forName(stringClassName); bean = aClass.newInstance(); //4.将上一步创建的对象返回 } catch (Exception e) { // 出现异常打印异常 e.printStackTrace(); //谁调用就把异常扔给谁 throw new RuntimeException(); } return bean; } }
调用方法通过工厂类创建被调用方对象
//1.面向接口创建studentService对象:需要手动new调用方的对象 //StudentService studentService = new StudentServiceImpl();
//2.面向接口+工厂模式创建studentService对象:无需调用方手动new调用方的对象,由BeanFactory来创建 StudentService studentService = (StudentService) BeanFactory.getBean("StudentService");
2.5.工厂类优化
工厂类加载时创建配置文件中配置的所有bean实例,避免调用方每次调用工厂类的getBean()方法都创建1次对象。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.itheima.factory; import java.util.Enumeration; import java.util.HashMap; import java.util.Map; import java.util.ResourceBundle; public class BeanFactory2 { //存储所有bean的HashMap private static Map<String, Object> beanMap = new HashMap<>(); //类加载时创建配置文件中配置的所有bean实例,避免调用方每次调用工厂类的getBean()方法都创建1次对象 static { try { //1.读取配置文件 ResourceBundle resourceBundle = ResourceBundle.getBundle("beans"); //2.遍历配置文件中所有key,实例化bena集中存放到beanMap中 Enumeration<String> keys = resourceBundle.getKeys(); while (keys.hasMoreElements()) { String key = keys.nextElement(); String stringClassName = resourceBundle.getString(key); Class aClass = Class.forName(stringClassName); Object instance = aClass.newInstance(); beanMap.put(key, instance); } } catch (Exception e) { e.printStackTrace(); throw new RuntimeException(); } } //获取bean public static Object getBean(String beanId) { Object bean = beanMap.get(beanId); return bean; } }
二、代理模式
23种设计模式中有一种代理模式。
使用代码模拟静态代理和动态代理;
- 目标对象(明星): 原始对象
- 代理对象(明星的经纪人):帮助原始对象的对象,一般用于在不改变原始对象的前提下,对原始对象的进行功能的增强。
1.静态代理
如果想要在不改变原始对象的前提下,使用代理对象增强原始对象的功能,那么原始对象和代理对象都需要实现同一个接口;
原始+代理对象的接口
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.itheima.test.proxy; //演员和经纪人都需要实现的接口 public interface Performer { //唱歌的方法 void sing(); //跳舞的方法 void dance(); }
原始对象的类
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.itheima.test.proxy; //男演员类实现了演员接口 public class Actor implements Performer { private String name; private Integer age; public Actor() { } public Actor(String name, Integer age) { this.name = name; this.age = age; } @Override public void sing() { System.out.printf("%s唱了一首歌\n", this.name); } @Override public void dance() { System.out.printf("%s跳了一支舞", this.name); } @Override public String toString() { return "actor{" + "name='" + name + '\'' + ", age=" + age + '}'; } }
代理对象的类
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.itheima.test.proxy; //经纪人类:再拥有演员功能的前提下,增加新的功能 public class Agent implements Performer { //经纪人服务的演员 private Performer performer; public Agent() { } public Agent(Performer performer) { this.performer = performer; } @Override public void sing() { System.out.println("经纪人帮助演员谈谈演出费用问题"); this.performer.sing(); System.out.println("经济人帮助演员收费"); System.out.println("经济人帮助演员照顾演员家里人"); } @Override public void dance() { System.out.println("经纪人帮助演员谈谈演出费用问题"); this.performer.dance(); System.out.println("经济人帮助演员收费"); System.out.println("经纪人帮助演员照顾演员家里人"); } }
2.动态代理
静态代理有以下弊端
- 实现了代理对象给原始对象添加新功能的需求;
- 但每新增1个原始对象都需要新增1代理对象,单独为这个原始对象服务 ;
动态代理
- 动态代理拥有静态代理的代理功能,即在不改变原始对象的前提下,使用代理对象增强原始对象的功能;
- 动态代理还可以在不定义代理类的前提下,直接创建1个代理对象,使用1个代理对象服务多个原始对象;
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.itheima.test.proxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class Customer { public static void main(String[] args) { //客户要求演员-宝强 唱首歌 //方式1:直接实例化1个演员类 Performer actor1 = new Actor("宝强", 41);//原始对象 actor1.sing(); System.out.println("----------------------------------------"); //方式2:客户要求演员-宝强 唱首歌, 需要找到宝强的经纪人,通过代理找到演员 Performer actor2 = new Actor("宝强", 41); Agent agent = new Agent(actor2); //代理对象 agent.sing(); System.out.println("----------------------------------------"); //方式3动态代理:虽然方式2实现了给原始对象添加功能的需求; // 但每1个演员都需要,创建1为单独的经纪人,能不能让多个演员公用1个代理人? //再简化一步:不定义代理类,直接创建代理对象 //代理对象=目标对象的功能+增强逻辑 //1.创建目标对象 Actor actor3 = new Actor("奶量", 41); //2.编写增强逻辑 //3.使用JDK动态创建代理对象 Performer instance = (Performer) Proxy.newProxyInstance( //指定1个类加载器:跟目标对象使用同一个类加载器 actor3.getClass().getClassLoader(), //接口:限制代理对象可以使用目标对象哪些方法? actor3.getClass().getInterfaces(), new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //调用目标对象的方法: //参数1:目标对象, //参数2:目标对象方法执行需要 System.out.println("经纪人帮助演员谈谈演出费用问题"); method.invoke(actor3, args); System.out.println("经济人帮助演员收费"); System.out.println("经济人帮助演员照顾演员家里人"); return null; } } ); //4.调用代理对象的方法 instance.sing(); instance.dance(); } }