目录
一.Spring
1.Spring IOC & AOP
IoC
IoC
（
Inverse of Control:
控制反转）是⼀种
设计思想
，就是
将原本在程序中⼿动创建对象的控制
权，交由
Spring
框架来管理。
IoC
在其他语⾔中也有应⽤，并⾮
Spring
特有。
IoC
容器是
Spring
⽤来实现
IoC
的载体，
IoC
容器实际上就是个
Map
（
key
，
value
）
,Map
中存放的是各种对象。
将对象之间的相互依赖关系交给
IoC
容器来管理，并由
IoC
容器完成对象的注⼊。这样可以很⼤程度上简化应⽤的开发，把应⽤从复杂的依赖关系中解放出来。 IoC
容器就像是⼀个⼯⼚⼀样，当我们需
要创建⼀个对象的时候，只需要配置好配置⽂件
/
注解即可，完全不⽤考虑对象是如何被创建出来的。
AOP
AOP(Aspect-Oriented Programming:
⾯向切⾯编程
)
能够将那些与业务⽆关，
却为业务模块所共同调⽤
的逻辑或责任（例如事务处理、⽇志管理、权限控制等）封装起来
，便于
减少系统的重复代码
，
降低模
块间的耦合度
，并
有利于未来的可拓展性和可维护性
。
Spring AOP
就是基于动态代理的
，如果要代理的对象，实现了某个接⼝，那么
Spring AOP
会使⽤
JDK
Proxy
，去创建代理对象，⽽对于没有实现接⼝的对象，就⽆法使⽤
JDK Proxy
去进⾏代理了，这时候Spring AOP会使⽤
Cglib
，这时候
Spring AOP
会使⽤
Cglib
⽣成⼀个被代理对象的⼦类来作为代理，如下图所示：
Spring AOP 和 AspectJ AOP 有什么区别？
2.Spring bean
(1) 作用域
(2) Spring 中的 bean ⽣命周期
https://www.cnblogs.com/zrtqsk/p/3735273.html
- Bean 容器找到配置⽂件中 Spring Bean 的定义。
- Bean 容器利⽤ Java Reflection API 创建⼀个Bean的实例。
- 如果涉及到⼀些属性值 利⽤ set() ⽅法设置⼀些属性值。
- 如果 Bean 实现了 BeanNameAware 接⼝，调⽤ setBeanName() ⽅法，传⼊Bean的名字。
- 如果 Bean 实现了 BeanClassLoaderAware 接⼝，调⽤ setBeanClassLoader() ⽅法，
- 传⼊ ClassLoader 对象的实例。
- 与上⾯的类似，如果实现了其他 *.Aware 接⼝，就调⽤相应的⽅法。
- 如果有和加载这个 Bean 的 Spring 容器相关的 BeanPostProcessor 对象，执
- ⾏ postProcessBeforeInitialization() ⽅法
- 如果Bean实现了 InitializingBean 接⼝，执⾏ afterPropertiesSet() ⽅法。
- 如果 Bean 在配置⽂件中的定义包含 init-method 属性，执⾏指定的⽅法。
- 如果有和加载这个 Bean的 Spring 容器相关的 BeanPostProcessor 对象，执
- ⾏ postProcessAfterInitialization() ⽅法
- 当要销毁 Bean 的时候，如果 Bean 实现了 DisposableBean 接⼝，执⾏ destroy() ⽅
- 法。
- 当要销毁 Bean 的时候，如果 Bean 在配置⽂件中的定义包含 destroy-method 属性，执⾏指定 的⽅法。
3.SpringMVC
(3) Spring 框架中⽤到了哪些设计模式
二.Mybatis
1.标签
2.Dao接口
3.返回与映射
4.延迟加载
三.Kafka
四.设计模式
1.IO 设计模式
https://github.com/Snailclimb/JavaGuide/blob/main/docs/java/io/io-design-patterns.md
2.Spring 中的设计模式详解
3.实践
图说设计模式 — Graphic Design Patterns （重点）
设计模式 | 菜鸟教程 （重点）
组合模式 Java 设计模式之组合模式及应用场景 | 菜鸟教程
外观模式 JAVA设计模式之门面模式（外观模式） | 菜鸟教程
享元模式 享元模式 | 菜鸟教程
代理模式 代理模式 | 菜鸟教程
CGLIB(Code Generation Library) 介绍与原理 | 菜鸟教程
注意事项： 1、和适配器模式的区别：适配器模式（接口实现）主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。 2、和装饰器模式的区别：装饰器模式为了增强功能（扩展抽象类），而代理模式是为了加以控制。
JDK 自带的动态代理
java.lang.reflect.Proxy:生成动态代理类和对象；
java.lang.reflect.InvocationHandler（处理器接口）：可以通过invoke方法实现
对真实角色的代理访问。
每次通过 Proxy 生成的代理类对象都要指定对应的处理器对象。
代码：
a) 接口：Subject.java
**
* @author gnehcgnaw
* @date 2018/11/5 19:29
*/
public interface Subject {
public int sellBooks();
public String speak();
}
b)真实对象：RealSubject.java
/**
* @author gnehcgnaw
* @date 2018/11/5 18:54
*/
public class RealSubject implements Subject{
@Override
public int sellBooks() {
System.out.println("卖书");
return 1 ;
}
@Override
public String speak() {
System.out.println("说话");
return "张三";
}
}
c)处理器对象：MyInvocationHandler.java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* 定义一个处理器
* @author gnehcgnaw
* @date 2018/11/5 19:26
*/
public class MyInvocationHandler implements InvocationHandler {
/**
* 因为需要处理真实角色，所以要把真实角色传进来
*/
Subject realSubject ;
public MyInvocationHandler(Subject realSubject) {
this.realSubject = realSubject;
}
/**
*
* @param proxy 代理类
* @param method 正在调用的方法
* @param args 方法的参数
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("调用代理类");
if(method.getName().equals("sellBooks")){
int invoke = (int)method.invoke(realSubject, args);
System.out.println("调用的是卖书的方法");
return invoke ;
}else {
String string = (String) method.invoke(realSubject,args) ;
System.out.println("调用的是说话的方法");
return string ;
}
}
}
d)调用端：Main.java
import java.lang.reflect.Proxy;
/**
* 调用类
* @author gnehcgnaw
* @date 2018/11/7 20:26
*/
public class Client {
public static void main(String[] args) {
//真实对象
Subject realSubject = new RealSubject();
MyInvocationHandler myInvocationHandler = new MyInvocationHandler(realSubject);
//代理对象
Subject proxyClass = (Subject) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Subject.class}, myInvocationHandler);
proxyClass.sellBooks();
proxyClass.speak();
}
}
Cglib 动态代理是针对代理的类, 动态生成一个子类, 然后子类覆盖代理类中的方法, 如果是private或是final类修饰的方法,则不会被重写。
CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。
CGLIB作为一个开源项目，其代码托管在github，地址为：https://github.com/cglib/cglib
需要代理的类:
package cn.cpf.pattern.structure.proxy.cglib;
public class Engineer {
// 可以被代理
public void eat() {
System.out.println("工程师正在吃饭");
}
// final 方法不会被生成的字类覆盖
public final void work() {
System.out.println("工程师正在工作");
}
// private 方法不会被生成的字类覆盖
private void play() {
System.out.println("this engineer is playing game");
}
}
CGLIB 代理类:
package cn.cpf.pattern.structure.proxy.cglib;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CglibProxy implements MethodInterceptor {
private Object target;
public CglibProxy(Object target) {
this.target = target;
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("### before invocation");
Object result = method.invoke(target, objects);
System.out.println("### end invocation");
return result;
}
public static Object getProxy(Object target) {
Enhancer enhancer = new Enhancer();
// 设置需要代理的对象
enhancer.setSuperclass(target.getClass());
// 设置代理人
enhancer.setCallback(new CglibProxy(target));
return enhancer.create();
}
}
测试方法:
import java.lang.reflect.Method;
import java.util.Arrays;
public class CglibMainTest {
public static void main(String[] args) {
// 生成 Cglib 代理类
Engineer engineerProxy = (Engineer) CglibProxy.getProxy(new Engineer());
// 调用相关方法
engineerProxy.eat();
}
}
运行结果:
### before invocation
工程师正在吃饭
### end invocation
CGLIB(Code Generation Library) 介绍与原理
https://www.runoob.com/w3cnote/cglibcode-generation-library-intro.html??? 责任链模式 责任链模式 | 菜鸟教程
观察者模式 观察者模式 | 菜鸟教程
策略模式与状态模式的区别 策略模式 VS 状态模式 | 菜鸟教程
七大原则记忆口诀：开口里合最单依
开：开闭原则
口：接口隔离原则
里：里氏替换原则
合：合成复用原则
最：最少知道原则（迪米特原则）
单：单一职责原则
依：依赖倒置原则
45万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
