Spring运行原理

Posted 2023-03-16

　　1、spring原理

spring的最大作用ioc/di,将类与类的依赖关系写在配置文件中，

程序在运行时根据配置文件动态加载依赖的类，降低的类与类之间

的藕合度。它的原理是在applicationContext.xml加入bean标记,

在bean标记中通过class属性说明具体类名、通过property标签说明

该类的属性名、通过constructor-args说明构造子的参数。其一切都是

返射，当通过applicationContext.getBean("id名称")得到一个类实例时，

就是以bean标签的类名、属性名、构造子的参数为准，通过反射实例对象，

唤起对象的set方法设置属性值、通过构造子的newInstance实例化得到对象。

正因为spring一切都是反射，反射比直接调用的处理速度慢，所以这也是spring

的一个问题。

spring第二大作用就是aop，其机理来自于代理模式，代理模式

有三个角色分别是通用接口、代理、真实对象

代理、真实对象实现的是同一接口，将真实对象作为

代理的一个属性，向客户端公开的是代理，当客户端

调用代理的方法时，代理找到真实对象，调用真实对象

方法，在调用之前之后提供相关的服务，如事务、安全、

日志。其名词分别是代理、真实对象、装备、关切点、连接点。

2、动态代理:不用写代理类，虚拟机根据真实对象实现的接口产生一个类，通过

类实例化一个动态代理，在实例化动态代理时将真实对象

及装备注入到动态代理中，向客户端公开的是动态代理，

当客户端调用动态代理方法时，动态代理根据类的返射得

到真实对象的Method,调用装备的invoke方法，将动态代理、

Method、方法参数传与装备的invoke方法，invoke方法在唤

起method方法前或后做一些处理。

1、产生动态代理的类:

java.lang.refect.Proxy

2、装备必须实现InvocationHandler接口实现invoke方法

3、反射

什么是类的返射?

通过类说明可以得到类的父类、实现的接口、内部类、构造函数、方法、属性

并可以根据构造器实例化一个对象，唤起一个方法，取属性值，改属性值。

如何得到一个类说明?

Class cls=类.class;

Class cls=对象.getClass();

Class.forName("类路径");

如何得到一个方法并唤起它?

Class cls=类.class;

Constructor cons=cls.getConstructor(new Class[]String.class);

Object obj=cons.newInstance(new Object[]"aaa");

Method method=cls.getMethod("方法名",new Class[]String.class,Integer.class);

method.invoke(obj,new Object[]"aa",new Integer(1));

4、spring的三种注入方式是什么?

setter

interface

constructor

5、spring的核心接口及核类配置文件是什么?

FactoryBean:工厂bean主要实现ioc/di

ApplicationContext ac=new FileXmlApplicationContext("applicationContext.xml");

Object obj=ac.getBean("id值");

applicationContext.xml 参考技术A 的。Struts本身就是 MVC 在这里负责将用户数据传人业务层，以及 将业务层处理的结果返回给用户，此系统属于较简单WEB应用，采用了OpenSessionInView模式处理LazyLoad问题，这样我们可以在用户视图中使用 get，set方法来方便地获取关联对象。为了处理庞大的Action和ActionForm问题，在此我门准备使用DynaActionForm (DynaValidatorForm)和DispatchAction以及 动态验证框架 来解决。及使用Tile来解决框架问题 。使用自定义标签处理分页和身份验证问题。

2 Spring

Spring Framework最得以出名的是与Hibernate的无缝链接，虽然Spring 对Hibernate提供了90％以上的封装，使我们不必去关心Session 的建立，关闭，以及事务使我们能够专心的关注业务逻辑。但是一些特殊情况如 有时需要Query以及Criteria 对象，分页等，Spring不能给我们提供支持，总不能每次都在你的DAO上写个HibernateCallBackup()吧？Spring的作用不是把Hibernate再封装一层，而是让你接触不到Hibernate的API，而是帮助你管理好Session和Transaction。

在这里解决方法是：首先 写一个IBase 的接口，和一个BaseDao的实现。在实现中仿照HibernateTemplate，将其功能一一实现，同时考虑到Spring 未能支持的地方，我们不得已只好自己来管理Session，因此加入public Session openSession()，public Query getQuery(String sql)，public Criteria getCriteria(Class clazz)，以及分页的方法。 然后为每一个Entity 都建立继承于以上类的IEntity，与EntityDao。这里可以根据需求对Entity加入特殊的方法实现，如 在 StudentsDao.java 中加入类似用户身份验证等。以上就是数据访问层。接下来在Service层中通过对dao的引用完成业务逻辑方法。在下面的例子中我们分别为学生模块，教师模块，管理员模块构建Service层，StudentsServiceImpl，TeachersServiceImpl，AdminServiceImpl。

3 Hibernate

有了Spring的封装，我们要对Hibernate做的就是正确实现对象关系的映射。由于此处处于系统的最底层，准确无误的实现对象之间的关联关系映射将起着至关重要的作用。

总之，理解了Struts，Spring，Hibernate地原理以及之间的关系之后，剩下的工作就如同在以Spring为核心的Struts为表现的框架中堆积木。

Spring Boot运行原理

Spring Boot运行原理

概述

　　　　本文主要写了下Spring Boot运行原理，还有一个小例子。

　　　　Spring4.x提供了基于条件来配置Bean的能力，而Spring Boot的实现也是基于这一原理的。

　　　　Spring Boot关于自动配置的源码在spring-boot-autoconfigure-1.3.0.x.jar内。如果想知道Spring Boot为我们做了哪些自动配置，可以查看这里的源码。

　　　　可以通过下面的几种方式查看当前项目中已启用可未启用的自动配置的报告：

　　　　　　　　1：运行jar时添加--debug参数：java -jar xx.jar --debug。

　　　　　　　　2：在application.properties中设置属性：debug=true。

　　　　　　　　3：也可以在开发工具中配置运行时参数，此处就不再截图了。

---

 

Spring Boot运作原理

　　　　关于Spring Boot的运作原理，还是要看@SpringBootApplication注解，这个注解是一个组合注解，它的核心功能是由@EnableAutoConfiguration注解提供的。

　　　　@EnableAutoConfiguration注解的源码如下：

 1 //
 2 // Source code recreated from a .class file by IntelliJ IDEA
 3 // (powered by Fernflower decompiler)
 4 //
 5 
 6 package org.springframework.boot.autoconfigure;
 7 
 8 import java.lang.annotation.Documented;
 9 import java.lang.annotation.ElementType;
10 import java.lang.annotation.Inherited;
11 import java.lang.annotation.Retention;
12 import java.lang.annotation.RetentionPolicy;
13 import java.lang.annotation.Target;
14 import org.springframework.boot.autoconfigure.AutoConfigurationPackages.Registrar;
15 import org.springframework.context.annotation.Import;
16 
17 @Target({ElementType.TYPE})
18 @Retention(RetentionPolicy.RUNTIME)
19 @Documented
20 @Inherited
21 @Import({EnableAutoConfigurationImportSelector.class, Registrar.class})
22 public @interface EnableAutoConfiguration {
23     Class<?>[] exclude() default {};
24 
25     String[] excludeName() default {};
26 }

　　　　这里的关键功能是@Import注解导入的配置功能，EnableAutoConfigurationImportSelector使用SpringFactoriesLoador.loadFactoryNames方法来扫描具有META-INF/spring.factories文件的jar包。

　　　　spring.factories文件中声名了一些自动配置，如：

　　　　　　　　

　　　　打开上面任意一个类，一般都有下面的条件注解，在spring-boot-autoconfigure-1.3.0.x.jar的org.springframwork.boot.autoconfigure.condition包下，条件注解如下。

　　　　　　　　@ConditionalOnBean：当容器里有指定的Bean的条件下。

　　　　　　　　@ConditionalOnClass：当类路径下有指定的类的条件下。
　　　　　　　　@ConditionalOnExpression：基于SpEL表达式作为判断条件。
　　　　　　　　@ConditionalOnOnJava：基于JVM版本作为判断条件。
　　　　　　　　@ConditionalOnJndi：在JNDI存在的条件下查找指定的位置。
　　　　　　　　@ConditionalOnMissingBean：当容器里没有指定Bean的情况下。
　　　　　　　　@ConditionalOnMissingClass：当类路径下没有指定的类的条件下。
　　　　　　　　@ConditionalOnNotWebApplication：当前项目不是Web项目的条件下。
　　　　　　　　@ConditionalOnProperty：指定的属性是否有指定的值。
　　　　　　　　@ConditionalOnResource：类路径是否有指定的值。
　　　　　　　　@ConditionalOnSingleCandidate：当·指定Bean在容器中只有一个，或者虽然有多个但是指定首选的Bean。
　　　　　　　　@ConditionalOnWenApplication：当前项目是Web项目的条件下。

　　　　这些注解都是组合了@Conditional元注解，只是使用了不同的条件。

　　　　下面我们来分析一下@ConditionalOnWebApplication注解。

 1 //
 2 // Source code recreated from a .class file by IntelliJ IDEA
 3 // (powered by Fernflower decompiler)
 4 //
 5 
 6 package org.springframework.boot.autoconfigure.condition;
 7 
 8 import java.lang.annotation.Documented;
 9 import java.lang.annotation.ElementType;
10 import java.lang.annotation.Retention;
11 import java.lang.annotation.RetentionPolicy;
12 import java.lang.annotation.Target;
13 import org.springframework.context.annotation.Conditional;
14 
15 @Target({ElementType.TYPE, ElementType.METHOD})
16 @Retention(RetentionPolicy.RUNTIME)
17 @Documented
18 @Conditional({OnWebApplicationCondition.class})
19 public @interface ConditionalOnWebApplication {
20 }

ConditionalOnWebApplication源码

 

 　　　　从源码可以看出，此注解使用的条件是OnWebApplicationCondition，下面我们来看看这个条件是如何构造的：

 1 //
 2 // Source code recreated from a .class file by IntelliJ IDEA
 3 // (powered by Fernflower decompiler)
 4 //
 5 
 6 package org.springframework.boot.autoconfigure.condition;
 7 
 8 import org.springframework.context.annotation.ConditionContext;
 9 import org.springframework.core.annotation.Order;
10 import org.springframework.core.type.AnnotatedTypeMetadata;
11 import org.springframework.util.ClassUtils;
12 import org.springframework.util.ObjectUtils;
13 import org.springframework.web.context.WebApplicationContext;
14 import org.springframework.web.context.support.StandardServletEnvironment;
15 
16 @Order(-2147483628)
17 class OnWebApplicationCondition extends SpringBootCondition {
18     private static final String WEB_CONTEXT_CLASS = "org.springframework.web.context.support.GenericWebApplicationContext";
19 
20     OnWebApplicationCondition() {
21     }
22 
23     public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
24         boolean webApplicationRequired = metadata.isAnnotated(ConditionalOnWebApplication.class.getName());
25         ConditionOutcome webApplication = this.isWebApplication(context, metadata);
26         if (webApplicationRequired && !webApplication.isMatch()) {
27             return ConditionOutcome.noMatch(webApplication.getMessage());
28         } else {
29             return !webApplicationRequired && webApplication.isMatch() ? ConditionOutcome.noMatch(webApplication.getMessage()) : ConditionOutcome.match(webApplication.getMessage());
30         }
31     }
32 
33     private ConditionOutcome isWebApplication(ConditionContext context, AnnotatedTypeMetadata metadata) {
34         if (!ClassUtils.isPresent("org.springframework.web.context.support.GenericWebApplicationContext", context.getClassLoader())) {
35             return ConditionOutcome.noMatch("web application classes not found");
36         } else {
37             if (context.getBeanFactory() != null) {
38                 String[] scopes = context.getBeanFactory().getRegisteredScopeNames();
39                 if (ObjectUtils.containsElement(scopes, "session")) {
40                     return ConditionOutcome.match("found web application \'session\' scope");
41                 }
42             }
43 
44             if (context.getEnvironment() instanceof StandardServletEnvironment) {
45                 return ConditionOutcome.match("found web application StandardServletEnvironment");
46             } else {
47                 return context.getResourceLoader() instanceof WebApplicationContext ? ConditionOutcome.match("found web application WebApplicationContext") : ConditionOutcome.noMatch("not a web application");
48             }
49         }
50     }
51 }

OnWebApplicationCondition源码

　　　　从isWebApplication方法可以看出，判断条件是：

　　　　　　　　1：GenericWebApplicationContext是否在类路径中；

　　　　　　　　2：容器里是否有名为session的scope；

　　　　　　　　3：当前容器的Enviroment是否为StandardServletEnvironment；

　　　　　　　　4：当前的ResourceLoader是否为WebApplicationContext(ResourceLoador是ApplicationContext的顶级接口之一)；

　　　　　　　　5：我们需要构造ConditionOutcome类的对象来帮助我们，最终通过ContitionOutcome.isMatch方法来返回布尔值来确定条件；

实例分析

　　　　通过上面写的，我们初步了解了Spring Boot的运作原理和主要的条件注解，下面来分析一个简单的Spring Boot内置的自动配置功能：http的编码配置。

　　　　在常规项目中，http编码一般是在web.xml中配置一个filter，如下：

 1 <filter>
 2     <filter-name>encodingFilter</filter-name>
 3     <filter-class>
 4         org.springframework.web.filter.CharacterEncodingFilter
 5     </filter-class>
 6     <init-param>
 7         <param-name>encoding</param-name>
 8         <param-value>UTF-8</param-value>
 9     </init-param>
10     <init-param>
11         <param-name>forceEncoding</param-name>
12         <param-value>true</param-value>
13     </init-param>
14 </filter>

　　　　由上可见，自动配置要满足两个条件：

　　　　　　　　1：能配置CharacterEncodingFilter这个Bean；

　　　　　　　　2：能配置encoding和forceEncoding这两个参数；

 

　　　　配置参数：

　　　　　　　　Spring Boot的自动配置是基于类型安全的配置，关于http编码的配置在HttpEncodingProperties类中，源码如下：

 1 //
 2 // Source code recreated from a .class file by IntelliJ IDEA
 3 // (powered by Fernflower decompiler)
 4 //
 5 
 6 package org.springframework.boot.autoconfigure.web;
 7 
 8 import java.nio.charset.Charset;
 9 import org.springframework.boot.context.properties.ConfigurationProperties;
10 
11 @ConfigurationProperties(
12         prefix = "spring.http.encoding"//在application.properties配置的时候前缀是spring.http.encoding。
13 )
14 public class HttpEncodingProperties {
15     public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");//默认编码方式UTF-8，如果要修改可以使用：spring.http.encoding.charset=编码。
16     private Charset charset;
17     private boolean force;
18 
19     public HttpEncodingProperties() {
20         this.charset = DEFAULT_CHARSET;
21         this.force = true;//设置forceEncoding，默认为true，若果要修改可以使用spring.http.encoding.force=false。
22     }
23 
24     public Charset getCharset() {
25         return this.charset;
26     }
27 
28     public void setCharset(Charset charset) {
29         this.charset = charset;
30     }
31 
32     public boolean isForce() {
33         return this.force;
34     }
35 
36     public void setForce(boolean force) {
37         this.force = force;
38     }
39 }

HttpEncodingProperties源码

 

 　　　　配置Bean：

　　　　　　　　通过调用上面的配置，并根据条件配置CharacterEncodingFilter的Bean，源码如下：

 1 //
 2 // Source code recreated from a .class file by IntelliJ IDEA
 3 // (powered by Fernflower decompiler)
 4 //
 5 
 6 package org.springframework.boot.autoconfigure.web;
 7 
 8 import org.springframework.beans.factory.annotation.Autowired;
 9 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
10 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
11 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
12 import org.springframework.boot.context.properties.EnableConfigurationProperties;
13 import org.springframework.boot.context.web.OrderedCharacterEncodingFilter;
14 import org.springframework.context.annotation.Bean;
15 import org.springframework.context.annotation.Configuration;
16 import org.springframework.web.filter.CharacterEncodingFilter;
17 
18 @Configuration
19 @EnableConfigurationProperties({HttpEncodingProperties.class})//开启属性注入，通过@EnableConfigurationProperties声明，使用@Autowired注入。
20 @ConditionalOnClass({CharacterEncodingFilter.class})//当CharacterEncodingFilter在类路径的条件下
21 @ConditionalOnProperty(
22         prefix = "spring.http.encoding",
23         value = {"enabled"},//当设置spring.http.encoding=enabled的情况下
24         matchIfMissing = true//如果没有设置，则默认为true，即条件符合。
25 )
26 public class HttpEncodingAutoConfiguration {
27     @Autowired
28     private HttpEncodingProperties httpEncodingProperties;
29 
30     public HttpEncodingAutoConfiguration() {
31     }
32 
33     @Bean//使用Java配置的方式配置CharacterEncodingFilter这个bean。
34     @ConditionalOnMissingBean({CharacterEncodingFilter.class})//如果容器中没有这个bean的时候新建bean。
35     public CharacterEncodingFilter characterEncodingFilter() {
36         CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
37         filter.setEncoding(this.httpEncodingProperties.getCharset().name());
38         filter.setForceEncoding(this.httpEncodingProperties.isForce());
39         return filter;
40     }
41 }

HttpEncodingAutoConfiguration源码

 

自己写一个starter pom

　　　　我们也可以仿照上面http编码配置的例子自己写一个自动配置。代码如下：

 1 package com.wisely.spring_boot_starter_hello;
 2 
 3 import org.springframework.boot.context.properties.ConfigurationProperties;
 4 
 5 /**
 6  * 属性配置
 7  */
 8 @ConfigurationProperties(prefix = "hello")
 9 public class HelloServiceProperties {
10 
11     private static final String MSG = "world";
12     
13     private String msg = MSG;
14 
15     public String getMsg() {
16         return msg;
17     }
18 
19     public void setMsg(String msg) {
20         this.msg = msg;
21     }
22 }

属性配置

 1 package com.wisely.spring_boot_starter_hello;
 2 
 3 /**
 4  * 判断依据类
 5  */
 6 public class HelloService {
 7     private String msg;
 8 
 9     public String sayHello() {
10         return "Hello" + msg;
11     }
12 
13     public String getMsg() {
14         return msg;
15     }
16 
17     public void setMsg(String msg) {
18         this.msg = msg;
19     }
20 }

判断依据类

 1 package com.wisely.spring_boot_starter_hello;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 5 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 6 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 7 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 8 import org.springframework.context.annotation.Bean;
 9 import org.springframework.context.annotation.Configuration;
10 
11 /**
12  * 自动配置类
13  */
14 @Configuration
15 @EnableConfigurationProperties(HelloServiceProperties.class)
16 @ConditionalOnClass(HelloService.class)
17 @ConditionalOnProperty(prefix = "hello", value = "enabled", matchIfMissing = true)
18 public class HelloServiceAutoConfiguration {
19 
20     @Autowired
21     private HelloServiceProperties helloServiceProperties;
22 
23     @Bean
24     @ConditionalOnMissingBean(HelloService.class)
25     public HelloService helloService() {
26         HelloService helloService = new HelloService();
27         helloService.setMsg(helloServiceProperties.getMsg());
28         return helloService;
29     }
30 }

自动配置类

　　　　在src/main/resources下新建META-INF/spring.factories，并添加代码：

　　　　

　　　　然后新建一个项目，在pom.xml添加依赖

　　　　

　　　　最后运行看效果。

 1 package com.wisely.ch6_5;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.boot.SpringApplication;
 5 import org.springframework.boot.autoconfigure.SpringBootApplication;
 6 import org.springframework.web.bind.annotation.RequestMapping;
 7 import org.springframework.web.bind.annotation.RestController;
 8 
 9 import com.wisely.spring_boot_starter_hello.HelloService;
10 @RestController
11 @SpringBootApplication
12 public class Ch65Application {
13     
14     @Autowired
15     HelloService helloService;
16     
17     @RequestMapping("/")
18     public String index(){
19         return helloService.sayHello();
20     }
21 
22     public static void main(String[] args) {
23         SpringApplication.run(Ch65Application.class, args);
24     }
25 }

运行