【Spring系列】- 手写模拟Spring框架
简单模拟Spring
生命不息,写作不止
继续踏上学习之路,学之分享笔记
总有一天我也能像各位大佬一样
一个有梦有戏的人 @怒放吧德德
分享学习心得,欢迎指正,大家一起学习成长!
前言
上次已经学习了Java的设计模式,接下来就先来学习一下如何手写模拟简易的Spring,通过动手实践,才会更好的了解spring底层原理,今天就简单的模拟Spring容器是如何创建,bean又是如何注入的。
来看一下本次案例的spring类图
Spring容器
模拟spring,首先就是需要一个容器,是Spring的核心,一切Spring bean都存储在Spring容器内,并由其通过IoC技术管理。Spring容器也就是一个bean工厂(BeanFactory)。应用中bean的实例化,获取,销毁等都是由这个bean工厂管理的。就像我们刚开始学习的时候接触的ApplicationContext,就是spring的容器,他就是为了完成容器的配置,初始化,管理bean的。因此笔者自己创建了一个LydApplicationContext来模拟简单的spring容器。
开始使用
首先通过new LydApplicationContext(AppConfig.class)
实例化对象,在通过applicationContext.getBean("userService")
去获得bean对象。然而在容器的初始化可是做了许多的事情,包括扫描、实例化bean等等操作。
初始容器创建:
public class LydApplicationContext {
private Class configClass;
public LydApplicationContext(Class configClass) { // 构造方法
this.configClass = configClass;
}
}
Spring扫描底层实现
Spring容器建好之后我们就需要通过配置文件的注解获取扫描路径,我们需要获取所有的bean,并且需要实例对象。在此我们需要一个配置文件,就是使用new LydApplicationContext(AppConfig.class)
实例携带的配置类,当然这里有好多的形式,也可以是通过xml文件来处理。
配置文件AppConfig.java
这个就是为了提供扫描的包路径的,不做任何操作,所以不需要其他代码。
@ComponentScan("com.lyd.service") // 扫描路径,扫描这个包下的
public class AppConfig {
}
通过注解存放这个包路径,在后面可以通过这个注解来获取包路径,所以就需要我们创建一个ComponentScan
注解。
编写ComponentScan注解
这个注解是用来spring容器扫描包为之提供包路径。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ComponentScan {
// 指定扫描路径
String value() default "";
}
编写Component注解
在Spring中,通过Component
注解将bean注入Spring容器中,这里我们也采用高这个注解。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
String value() default "";
}
获取包路径
既然已经通过注解将包路径存在配置类中,接下来就可以通过这个注解来得到。但是,在这里需要注意的是,我们扫描的并非是java源文件,而是编译后的class文件。我们需要在LydApplicationContext
的构造方法中去实现。
首先,我们需要通过isAnnotationPresent方法先判断是否存在ComponentScan
注解,在通过类的getAnnotation
方法来得到注解。这样就可以直接得到注解上的值。这个值就是我们写入的包路径,注意,这里的路径是com.lyd.service,而我们需要用替换方法将'.'替换成'/',因为在后面获取资源路径的时候,用的是com/lyd/service
这种形式,也就是相对路径。
接下来需要获取资源路径,这个时候就需要用到类加载器LydApplicationContext.class.getClassLoader()
,类加载器中有一个getResource(path)
方法,这个可以根据传入的路径获取相应的资源,最后是能够拼出我们需要的绝对路径。
if (configClass.isAnnotationPresent(ComponentScan.class)) {
ComponentScan componentScanAnnotation = (ComponentScan) configClass.getAnnotation(ComponentScan.class);
// 1.1 扫描路径:只是个包名,扫描的是java的class文件,而并非源文件,com.lyd.service
String path = componentScanAnnotation.value();
// 1.2 将路径文件替换成/的形式
path = path.replace(".","/");
// 1.3 通过类加载器获取资源路径
ClassLoader classLoader = LydApplicationContext.class.getClassLoader();
URL resource = classLoader.getResource(path);
// 1.4 转成文件形式,主要是为了获取他的绝对地址
File file = new File(resource.getFile());
System.out.println(file);
}
通过类加载器得到的资源有个获取File的方法,然后我们通过File file = new File(resource.getFile())
;将资源转成File类型,因为他可以表示一个地址或者是具体文件。扫描就是扫描文件路径,也就是文件夹。我们可以打印看一下这个地址:
判断是否为文件夹,如果是,那就获取里面的所有文件,在通过遍历这些文件,获取绝对路径。
if (file.isDirectory()) { // 如果是文件夹
File[] files = file.listFiles();
for (File f : files) {
String absolutePath = f.getAbsolutePath(); // 获取绝对路径
System.out.println("绝对路径:" + absolutePath);
}
}
我们可以打印出来看一下:
因为我们要的是编译的.class文件,因此需要在遍历文件的时候进行判断文件是否为.class文件。为了拿到这个类,需要通过全限定名使用类加载器获取类 ,也就是利用反射机制。我们都知道,spring是通过Component注解来将bean注入spring的,因此最后就是通过判断是否有这个注解来得到一个bean。
for (File f : files) {
String absolutePath = f.getAbsolutePath(); // 获取绝对路径
System.out.println("绝对路径:" + absolutePath);
// 1.5 对编译文件进行处理
if (absolutePath.endsWith(".class")) { // 判断是否为编译文件
/**
* 需要拿到的是编译文件,通过类加载器去获取
* 需要将com\lyd\service\UserService转成com.lyd.service.UserService
*/
String className = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class"));
className = className.replace("\\", ".");
System.out.println("类名:" + className);
try {
// 1.6 通过全限定名使用类加载器获取类 (利用反射机制)
Class<?> clazz = classLoader.loadClass(className);
// 1.7 在通过这个clazz(类)来判断是否有component注解,有则是bean
if (clazz.isAnnotationPresent(Component.class)) {
// 到这里就是一个bean
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
最后我们需要的地址就是如下:
Spring生成BeanDefinition
在我们Spring容器启动或者是扫描的时候,并不建议直接实例化bean对象,因为bean是区分单例和多例的,多例bean我们是需要用到的时候再去创建。这个时候就需要生成BeanDefinition,即bean的定义,这个类存储了类和作用域(单例还是多例)。
定义Scope注解
通过Scope这个注解来标明是单例bean还是多例bean。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Scope {
String value() default "";
}
定义BeanDefinition
在spring中,不会在获取bean的时候再去解析是否为单例,而是通过BeanDefinition类来操作。对bean的定义,记录了bean类和作用域。
public class BeanDefinition {
private Class type;
private String scope; // 单例多例
public Class getType() {
return type;
}
public void setType(Class type) {
this.type = type;
}
public String getScope() {
return scope;
}
public void setScope(String scope) {
this.scope = scope;
}
}
因为我们注入spring的bean对象是有Component注解,因此在扫描的时候,我们会通过这个获得到bean,在这时候去创建BeanDefinition对象。通过判断注解上的值来赋值其作用域,如果没有设置,就默认是单例模式。
创建好的bean对象,我们还需要将他进行保存起来,这个就需要定义ConcurrentHashMap<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>()
;存储beanDefinition。key是component的值,如果component没有传入beanName的值,那就使用spring的命名规则,采用类名首字母小写。
// 1.7 在通过这个clazz(类)来判断是否有component注解,有则是bean
if (clazz.isAnnotationPresent(Component.class)) {
Component annotation = clazz.getAnnotation(Component.class);
String beanName = annotation.value();
// * 默认生成bean,如果只使用Component注解,没有写上beanName的值,那么就需要自动生成
if (beanName.equals("")) {
// 默认开头小字母
beanName = Introspector.decapitalize(clazz.getSimpleName());
}
/**
* 這就是一个bean了
* 然而在这里并不是直接就创建bean了,bean分为了单例bean和多例bean
*/
BeanDefinition beanDefinition = new BeanDefinition();
beanDefinition.setType(clazz);
if (clazz.isAnnotationPresent(Scope.class)) { // 判断是单例还是多例
Scope scope = clazz.getAnnotation(Scope.class);
beanDefinition.setScope(scope.value());
} else {
beanDefinition.setScope("singleton");
}
beanDefinitionMap.put(beanName, beanDefinition);
}
getBean底层
通过传来一个beanName,通过beanDefinitionMap中获取key为beanName的BeanDefinition对象,进行判空处理。这样我们可以通过这个BeanDefinition对象去获取作用域,判断是否为单例。
获取bean
在此,我们创建单例的时候,是需要将单例保存起来的,需要定义ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>()
;单例池来保存单例bean。然后在getBean的时候,如果是单例bean,就可以先去单例池中寻找,如果没找到,再去创建对象。而多例模式就需要每次都去创建。
// 获取bean对象
public Object getBean(String beanName) {
BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
if (beanDefinition == null) {
throw new NullPointerException("找不到bean名字为[" + beanName + "]的bean对象");
} else { // 找到就做相应的操作
String scope = beanDefinition.getScope();
if (scope.equals("singleton")) {
// 通过单例池获取
Object bean = singletonObjects.get(beanName);
if (bean == null) {
// 单例池中如果没有bean,就需要去创建
bean = createBean(beanName, beanDefinition);
singletonObjects.put(beanName, bean);
}
return bean;
} else {
// 多例的就不需要记录,每次都是通过创建
return createBean(beanName, beanDefinition);
}
}
}
创建bean
利用反射机制,通过无参构造方法去获取实例,这里就是bean对象实例了。就可以直接返回。
// 创建bean
private Object createBean(String beanName, BeanDefinition definition) {
// 利用反射获取实例,采用无参构造方法
Class clazz = definition.getType();
// 通过无参构造方法获取实例
try {
Object instance = clazz.getConstructor().newInstance(); // 到这里直接返回,bean的对象也就创建完成
return instance;
} catch (InstantiationException e) {
e.printStackTrace();
}
return null;
}
在构造方法扫描后要根据生成的beanDefinitionMap去创建单例bean对象。
// 2 创建单例bean对象
for (String beanName : beanDefinitionMap.keySet()) {
BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
if (beanDefinition.getScope().equals("singleton")) { // 那么,如何保证单例呢?就需要有个单例池,singletonObjects
Object bean = createBean(beanName, beanDefinition);
singletonObjects.put(beanName, bean); // 将单例bean存到单例池中
}
}
运行
public class Test {
public static void main(String[] args) {
LydApplicationContext applicationContext = new LydApplicationContext(AppConfig.class);
System.out.println(applicationContext.getBean("userService"));
System.out.println(applicationContext.getBean("userService"));
System.out.println(applicationContext.getBean("userService"));
System.out.println(applicationContext.getBean("userService"));
System.out.println(applicationContext.getBean("userService"));
}
}
我们可以先使用单例模式进行测试,我们不加scope注解,并且获取多个bean,可以看到得到的bean对象是同一个。
多例的时候在scope标上值,就可以看到每次获取的bean对象都是不一样的。
Autowired自动依赖注入
当我们在UserService中使用RoleService,我们就需要通过Autowired注解进行依赖注入。就是需要在createBean方法中,在创建实例之后,获取类中的字段,进行依赖注入,要通过判断Autowried注解。通过字段的set方法,将bean对象注入,而这个对象如何获得呢?那就是用过getBean()方法。
// 3 依赖注入
for (Field field : clazz.getDeclaredFields()) {
// 判断字段上是否存在Autowried注解
if (field.isAnnotationPresent(Autowired.class)) {
/**
* 值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。
* 值为 false 则指示反射的对象应该实施 Java 语言访问检查;
* 实际上setAccessible是启用和禁用访问安全检查的开关,并不是为true就能访问为false就不能访问 ;
*/
field.setAccessible(true); // 反射需要设置这个,不然无法赋值
// 用其属性名,这就意味着private RoleService roleService;roleService不能乱取
field.set(instance, getBean(field.getName()));
}
}
Aware回调机制与初始化
Aware回调
那如果我们需要获取当前bean的名字呢?那就得通过Aware回调机制。我们需要创建一个BeanNameAware接口,里面提供一个setBeanName方法。
public interface BeanNameAware {
public void setBeanName(String beanName);
}
在createBean方法中去编写回调机制,通过判断这个实例是否有BeanNameAware这个类,通过setName方法间接传递了beanName。
// 4 Aware回调机制
if (instance instanceof BeanNameAware) {
((BeanNameAware)instance).setBeanName(beanName);
}
在UserService方法中去实现这个BeanNameAware方法,这就能够在UserService里的beanName字段中得到这个bean对象的真实的beanName了。
@Component("userService") // 注入spring
@Scope("property")
public class UserService implements BeanNameAware, InitializingBean {
@Autowired
private RoleService roleService; // 依赖注入,加上@Autowired注解
private String beanName;
@Override
public void setBeanName(String beanName) {
this.beanName = beanName;
}
public void test() {
System.out.println("RoleService: " + roleService);
}
@Override
public void afterPropertiesSet() {
// ......
System.out.println("初始化");
}
}
初始化
在spring容器中,不只是完成bean对象的创建,还需要能够对bean进行初始化。需要创建InitializingBean接口类。
public interface InitializingBean {
public void afterPropertiesSet();
}
在需要进行初始化的bean对象去实现这个接口的方法,这里main可以进行一些操作。在createBean中,会根据判断是否有InitializingBean类,会在实例化之后调用这个方法进行初始化。
// 5 初始化
if (instance instanceof InitializingBean) {
((InitializingBean)instance).afterPropertiesSet();
}
结果
BeanPostProcessor
BeanPostProcessor可以对spring中bean的创建去做一些操作。
BeanPostProcessor接口
在spring中定义一个BeanPostProcessor接口,里面会有初始化前后操作的方法,并且将beanName和bean对象带入进行自定义的操作。
public interface BeanPostProcessor {
public Object postBeforeProcessor(String beanName, Object bean); // 初始化前
public Object postAfterProcessor(String beanName, Object bean); // 初始化后
}
自定义BeanPostProcessor
这里可以定义自己的类去实现spring中的BeanPostProcessor,对初始化进行一些相应操作。并且能够根据某个bean对象来做不同的操作。原理就是将MyBeanPostProcessor注入到容器中,在扫描的时候将这个对象保存起来,在创建bean的时候去遍历BeanPostProcessor集合,在去调用这个实例的方法。
@Component // 需要注入spring
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postBeforeProcessor(String beanName, Object bean) {
System.out.println("初始化前的bean:" + beanName + " -- " + bean);
return bean;
}
@Override
public Object postAfterProcessor(String beanName, Object bean) {
System.out.println("初始化后的bean:" + beanName + " -- " + bean);
return bean;
}
}
然而,在spring扫描的时候会进行操作,因为自己实现的BeanPostProcessor是通过Component注解注入spring容器的。因此可以通过判断有Component注解时候,进行判断是否含有BeanPostProcessor类,如果有生成BeanPostProcessor对象,并且将其实例添加到beanPostProcessorList容器中。在此就需要定义ArrayList<BeanPostProcessor> beanPostProcessorList = new ArrayList<>()
;来记录BeanPostProcessor。
// 6 判断是否是并加入beanPostProcessorList,这里不能使用instanceof
if (BeanPostProcessor.class.isAssignableFrom(clazz)) {
// 直接生成对象
BeanPostProcessor instance = (BeanPostProcessor) clazz.newInstance();
// 然后保存进去
beanPostProcessorList.add(instance);
}
接着就可以在创建bean对象的时候,在初始化前后去遍历这个BeanPostProcessor链表,调用相应的方法,就能够调用自定义的MyBeanPostProcessor的方法。
// 6 BeanPostProcessor 初始化前 AOP 遍历beanPostProcessorList
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
instance = beanPostProcessor.postBeforeProcessor(beanName, instance);
}
// 5 初始化
if (instance instanceof InitializingBean) {
((InitializingBean)instance).afterPropertiesSet();
}
// 6 BeanPostProcessor 初始化后 AOP
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
instance = beanPostProcessor.postAfterProcessor(beanName, instance);
}
运行结果:.
AOP机制
需要通过代理对象。这样如果不进行操作,返回的对象还是原来的,如果是通过操作了,那么返回的就是代理的对象。这里就简单的打印一句话。在扫描的时候,扫到userService这个bean的时候,返回的实例就是代理对象。
@Override
public Object postAfterProcessor(String beanName, Object bean) {
System.out.println("初始化后的bean:" + beanName + " -- " + bean);
if (beanName.equals("userService")) {
// 创建一个代理对象, 代理的是UserInterface这个
Object proxyInstance = Proxy.newProxyInstance(MyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
@Override
/**
* proxy:代理对象
* method:代理对象当前正在执行的方法
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("切面逻辑");
return method.invoke(bean, args);
}
});
return proxyInstance;
}
return bean;
}
源码备注
spring
LydApplicationContext
public class LydApplicationContext {
private Class configClass; // 注入的配置类
private ConcurrentHashMap<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(); // key是component名字
private ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>(); // 单例池
private ArrayList<BeanPostProcessor> beanPostProcessorList = new ArrayList<>(); // 记录BeanPostProcessor,在扫描的时候判断,使用
public LydApplicationContext(Class configClass) { // 构造方法
this.configClass = configClass;
// spring容器创建之后
// 1 扫描
// 通过配置文件的注解获取扫描路径
if (configClass.isAnnotationPresent(ComponentScan.class)) {
ComponentScan componentScanAnnotation = (ComponentScan) configClass.getAnnotation(ComponentScan.class);
// 1.1 扫描路径:只是个包名,扫描的是java的class文件,而并非源文件,com.lyd.service
String path = componentScanAnnotation.value();
// 1.2 将路径文件替换成/的形式
path = path.replace(".","/");
// 1.3 通过类加载器获取资源路径
ClassLoader classLoader = LydApplicationContext.class.getClassLoader();
URL resource = classLoader.getResource(path);
// 1.4 转成文件形式,主要是为了获取他的绝对地址
File file = new File(resource.getFile());
// System.out.println(file);
if (file.isDirectory()) { // 如果是文件夹
File[] files = file.listFiles();
for (File f : files) {
String absolutePath = f.getAbsolutePath(); // 获取绝对路径
System.out.println("绝对路径:" + absolutePath);
// 1.5 对编译文件进行处理
if (absolutePath.endsWith(".class")) { // 判断是否为编译文件
/**
* 需要拿到的是编译文件,通过类加载器去获取
* 需要将com\lyd\service\UserService转成com.lyd.service.UserService
*/
String className = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class"));
className = className.replace("\\", ".");
System.out.println("类名:" + className);
try {
// 1.6 通过全限定名使用类加载器获取类 (利用反射机制)
Class<?> clazz = classLoader.loadClass(className);
// 1.7 在通过这个clazz(类)来判断是否有component注解,有则是bean
if (clazz.isAnnotationPresent(Component.class)) {
// 6 判断是否是并加入beanPostProcessorList,这里不能使用instanceof
if (BeanPostProcessor.class.isAssignableFrom(clazz)) {
// 直接生成对象
BeanPostProcessor instance = (BeanPostProcessor) clazz.newInstance();
// 然后保存进去
beanPostProcessorList.add(instance);
}
Component annotation = clazz.getAnnotation(Component.class);
String beanName = annotation.value();
// * 默认生成bean,如果只使用Component注解,没有写上beanName的值,那么就需要自动生成
if (beanName.equals("")) {
// 默认开头小字母
beanName = Introspector.decapitalize(clazz.getSimpleName());
}
/**
* 這就是一个bean了
* 然而在这里并不是直接就创建bean了,bean分为了单例bean和多例bean
*/
BeanDefinition beanDefinition = new BeanDefinition();
beanDefinition.setType(clazz);
if (clazz.isAnnotationPresent(Scope.class)) { // 判断是单例还是多例
Scope scope = clazz.getAnnotation(Scope.class);
beanDefinition.setScope(scope.value());
} else {
beanDefinition.setScope("singleton");
}
beanDefinitionMap.put(beanName, beanDefinition);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
// 2 创建单例bean对象
for (String beanName : beanDefinitionMap.keySet()) {
BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
if (beanDefinition.getScope().equals("singleton")) { // 那么,如何保证单例呢?就需要有个单例池,singletonObjects
Object bean = createBean(beanName, beanDefinition);
singletonObjects.put(beanName, bean); // 将单例bean存到单例池中
}
}
}
// 创建bean
private Object createBean(String beanName, BeanDefinition definition) {
// 利用反射获取实例,采用无参构造方法
Class clazz = definition.getType();
// 通过无参构造方法获取实例
try {
Object instance = clazz.getConstructor().newInstance(); // 到这里直接返回,bean的对象也就创建完成
// 3 依赖注入
for (Field field : clazz.getDeclaredFields()) {
// 判断字段上是否存在Autowried注解
if (field.isAnnotationPresent(Autowired.class)) {
/**
* 值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。
* 值为 false 则指示反射的对象应该实施 Java 语言访问检查;
* 实际上setAccessible是启用和禁用访问安全检查的开关,并不是为true就能访问为false就不能访问 ;
*/
field.setAccessible(true); // 反射需要设置这个,不然无法赋值
// 用其属性名,这就意味着private RoleService roleService;roleService不能乱取
field.set(instance, getBean(field.getName()));
}
}
// * instanceof:是针对某个对象去判断是否实现某个类
// 4 Aware回调机制
if (instance instanceof BeanNameAware) {
((BeanNameAware)instance).setBeanName(beanName);
}
// 6 BeanPostProcessor 初始化前 AOP 遍历beanPostProcessorList
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
instance = beanPostProcessor.postBeforeProcessor(beanName, instance);
}
// 5 初始化
if (instance instanceof InitializingBean) {
((InitializingBean)instance).afterPropertiesSet();
}
// 6 BeanPostProcessor 初始化后 AOP
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
instance = beanPostProcessor.postAfterProcessor(beanName, instance);
}
return instance;
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
return null;
}
// 获取bean对象
public Object getBean(String beanName) {
BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
if (beanDefinition == null) {
throw new NullPointerException("找不到bean名字为[" + beanName + "]的bean对象");
} else { // 找到就做相应的操作
String scope = beanDefinition.getScope();
if (scope.equals("singleton")) {
// 通过单例池获取
Object bean = singletonObjects.get(beanName);
if (bean == null) {
// 单例池中如果没有bean,就需要去创建
bean = createBean(beanName, beanDefinition);
singletonObjects.put(beanName, bean);
}
return bean;
} else {
// 多例的就不需要记录,每次都是通过创建
return createBean(beanName, beanDefinition);
}
}
}
}
service
test
public class Test {
public static void main(String[] args) {
LydApplicationContext applicationContext = new LydApplicationContext(AppConfig.class);
// UserService userService = (UserService) applicationContext.getBean("userService");
UserInterface userService = (UserInterface) applicationContext.getBean("userService");
// System.out.println(applicationContext.getBean("userService"));
// System.out.println(applicationContext.getBean("roleService"));
userService.test();
}
}
创作不易,如有错误请指正,感谢观看!记得点赞哦!
【Spring系列】- 手写模拟Spring框架的更多相关文章
- 带你手写基于 Spring 的可插拔式 RPC 框架(一)介绍
概述 首先这篇文章是要带大家来实现一个框架,听到框架大家可能会觉得非常高大上,其实这和我们平时写业务员代码没什么区别,但是框架是要给别人使用的,所以我们要换位思考,怎么才能让别人用着舒服,怎么样才能让 ...
- 朱晔和你聊Spring系列S1E1:聊聊Spring家族的几大件
朱晔和你聊Spring系列S1E1:聊聊Spring家族的几大件 [下载本文PDF进行阅读] Spring家族很庞大,从最早先出现的服务于企业级程序开发的Core.安全方面的Security.到后来的 ...
- 剖析手写Vue,你也可以手写一个MVVM框架
剖析手写Vue,你也可以手写一个MVVM框架# 邮箱:563995050@qq.com github: https://github.com/xiaoqiuxiong 作者:肖秋雄(eddy) 温馨提 ...
- 手写开源ORM框架介绍
手写开源ORM框架介绍 简介 前段时间利用空闲时间,参照mybatis的基本思路手写了一个ORM框架.一直没有时间去补充相应的文档,现在正好抽时间去整理下.通过思路历程和代码注释,一方面重温下知识,另 ...
- 闭关修炼180天--手写持久层框架(mybatis简易版)
闭关修炼180天--手写持久层框架(mybatis简易版) 抛砖引玉 首先先看一段传统的JDBC编码的代码实现: //传统的JDBC实现 public static void main(String[ ...
- 带你手写基于 Spring 的可插拔式 RPC 框架(四)代理类的注入与服务启动
上一章节我们已经实现了从客户端往服务端发送数据并且通过反射方法调用服务端的实现类最后返回给客户端的底层协议. 这一章节我们来实现客户端代理类的注入. 承接上一章,我们实现了多个底层协议,procoto ...
- Spring源码 20 手写模拟源码
参考源 https://www.bilibili.com/video/BV1tR4y1F75R?spm_id_from=333.337.search-card.all.click https://ww ...
- 【spring】-- 手写一个最简单的IOC框架
1.什么是springIOC IOC就是把每一个bean(实体类)与bean(实体了)之间的关系交给第三方容器进行管理. 如果我们手写一个最最简单的IOC,最终效果是怎样呢? xml配置: <b ...
- 带你手写基于 Spring 的可插拔式 RPC 框架(五)注册中心
注册中心代码使用 zookeeper 实现,我们通过图片来看看我们注册中心的架构. 首先说明, zookeeper 的实现思路和代码是参考架构探险这本书上的,另外在 github 和我前面配置文件中的 ...
随机推荐
- KingbaseES 参数 - ora_statement_level_rollback
参数 ora_statement_level_rollback 控制KingbaseES 是否实现类似oracle 语句级的回滚.当该参数打开时,如果事务操作失败,仅会回滚最后一条操作,避免了全部操作 ...
- 【Git进阶】基于文件(夹)拆分大PR
背景 前段时间为了迁移一个旧服务到新项目,由此产生了一个巨大的PR,为了方便Code Review,最终基于文件夹,将其拆分成了多个较小的PR:现在这里记录下,后面可能还会需要. 演示 为了方便演示, ...
- URL slug是什么?
URL slug是什么? URL slug是 URL 中最后一个反斜杠之后的部分. 为什么slug 对 SEO 很重要? slug 对于关键字 SEO 来说非常强大.如果用户要在 Google 搜索& ...
- 快速排序C语言版图文详解
算法原理:选一个数位基准,将序列分成两个部分,一边全是比它小序列,另一边全是比它大序列.然后再分别对比他小的序列和比再次进行基准分割.依次分割下去,得到一个有序的队列. 原理图示: 编辑 编辑 ...
- elementUI中page(分页)的使用方法
HTML部分 <!-- 快捷键 page-div --> <el-pagination background layout="sizes,prev, pager, next ...
- Ubuntu22.04 安装配置VNC Server
如果转载, 请注明出处 https://www.cnblogs.com/milton/p/16730512.html Ubuntu22.40下VNC和远程桌面的区别 使用远程桌面时, 用户必须在hos ...
- Linux 宝塔部署 ASP.NET Core 应用
第一步,发步应用 我这是一个API 应用和 MVC 应用 设置,服务器上要运行的端口 API 端口5000 MVC 端口5001 打包文件夹,发步 1.桌面新建俩个文件夹 2.右键项目发步,选中iis ...
- Vue子->父组件传值
父组件引入: Import Test from'' 父页面使用: <Test ref="test" @m1="m2"><Test/> 子 ...
- 努力一周,开源一个超好用的接口Mock工具——Msw-Tools
作为一名前端开发,是不是总有这样的体验:基础功能逻辑和页面UI开发很快速,本来可以提前完成,但是接口数据联调很费劲,耗时又耗力,有时为了保证进度还不得不加加班. 为了摆脱这种痛苦,经过一周的努力,从零 ...
- [题解] Atcoder Beginner Contest ABC 265 Ex No-capture Lance Game DP,二维FFT
题目 首先明确先手的棋子是往左走的,将其称为棋子1:后手的棋子是往右走的,将其称为棋子2. 如果有一些行满足1在2右边,也就是面对面,那其实就是一个nim,每一行都是一堆石子,数量是两个棋子之间的空格 ...