Spring和Spring Boot相关知识整理

我不是女神ヾ 2022-12-10 10:07 161阅读 0赞

## 1、 思维导图 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ1MjcwNjY3_size_1_color_FFFFFF_t_70_pic_center]

> **说明：** 使用@Configuration在java代码中声明一个bean——而不是使用xml——实际上很早就有了（至少在《Spring实战(第3版)》出版时，也就是Spring3.0时），我一直以为是SpringBoot的新特性。

## 2、 Spring ##

**（1）AOP术语**

1.  通知Advice ——切面要做什么，何时执行。何时，包括方法调用前、方法调用后、方法成功调用后、方法调用抛异常后、环绕(Around)。环绕允许提供一些需要跨越方法调用前后的功能，如计算调用耗时。
2.  连接点Joinpoint —— 应用执行时能插入切面的点。实际上是一个逻辑概念，不体现在配置中。
3.  切点Pointcut —— 执行通知的具体的连接点。
4.  切面Aspect —— 通知+切点
5.  引入Introduction ——允许为类添加新的方法或属性。（个人理解即应用使用切面中的方法和属性，就好像这些方法和属性是原生的一样。可以参考aop:declare-parents元素）
6.  织入Weaving —— 将切面应用到目标对象创建新的代理对象的过程，Spring使用的是运行时。编译期和类加载时是其他的方式。

**（2） Bean的生命周期**  
虽然被称为生命周期，实际上指的是bean在初始化、回收期间调用了哪些方法。如果只看《Spring实战》，可以看到类似下面的图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ1MjcwNjY3_size_1_color_FFFFFF_t_70_pic_center 1]

**（3） Cglib和JdkProxy**

1、与Spring的关系

这是Spring AOP的两种实现方式。根据官方文档：

*  默认使用JdkProxy
 *  对于被代理对象没有实现任何接口，使用Cglib
 *  可以强制指定使用Cglib。这样就可以解释为什么有的bean实现了接口，有的没有，但是在同一个工程中可以并存了。

2、示例代码

//用户管理接口
    public interface UserManager { 
        //新增用户抽象方法
        void addUser(String userName,String password);
        //删除用户抽象方法
        void delUser(String userName);
    }

//用户管理实现类,实现用户管理接口
    public class UserManagerImpl implements UserManager{ 
        @Override
        public void addUser(String userName) { 
            System.out.println("调用了新增的方法！");
            System.out.println("传入参数为 userName: "+userName+" password: "+password);
        }
        @Override
        public void delUser(String userName) { 
            System.out.println("调用了删除的方法！");
            System.out.println("传入参数为 userName: "+userName);
        }   
    }

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    import com.lf.shejimoshi.proxy.entity.UserManager;
    import com.lf.shejimoshi.proxy.entity.UserManagerImpl;
    //JDK动态代理实现InvocationHandler接口
    public class JdkProxy implements InvocationHandler { 
        private Object target ;//需要代理的目标对象
        
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            System.out.println("JDK动态代理，监听开始！");
            Object result = method.invoke(target, args);
            System.out.println("JDK动态代理，监听结束！");
            return result;
        }
        //定义获取代理对象方法
        // 因为只是在main()里测试，声明为private了 
        private Object getJDKProxy(Object targetObject){ 
            this.target = targetObject;
            return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(), this);
        }
        
        public static void main(String[] args) { 
            JdkProxy jdkProxy = new JdkProxy();
            UserManager user = (UserManager) jdkProxy.getJDKProxy(new UserManagerImpl());//获取代理对象
            user.addUser("admin");
        }   
    }

import java.lang.reflect.Method;
    
    import com.lf.shejimoshi.proxy.entity.UserManager;
    import com.lf.shejimoshi.proxy.entity.UserManagerImpl;
    
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    //Cglib动态代理，实现MethodInterceptor接口
    public class CglibProxy implements MethodInterceptor { 
        private Object target;//需要代理的目标对象
        
        //重写拦截方法
        @Override
        public Object intercept(Object obj, Method method, Object[] arr, MethodProxy proxy) throws Throwable { 
            System.out.println("Cglib动态代理，监听开始！");
            Object invoke = method.invoke(target, arr);//方法执行，参数：target 目标对象 arr参数数组
            System.out.println("Cglib动态代理，监听结束！");
            return invoke;
        }
        //定义获取代理对象方法
        public Object getCglibProxy(Object objectTarget){ 
            //为目标对象target赋值
            this.target = objectTarget;
            Enhancer enhancer = new Enhancer();
            //设置父类,因为Cglib是针对指定的类生成一个子类，所以需要指定父类
            enhancer.setSuperclass(objectTarget.getClass());
            enhancer.setCallback(this);// 设置回调 
            Object result = enhancer.create();//创建并返回代理对象
            return result;
        }
        
        public static void main(String[] args) { 
            CglibProxy cglib = new CglibProxy();
            UserManager user =  (UserManager) cglib.getCglibProxy(new UserManagerImpl());
            user.delUser("admin");
        }
        
    }

3、比较  
比较一下两者的区别，这也是常见的面试问题。

<table> 
 <thead> 
  <tr> 
   <th align="center"></th> 
   <th align="center">JdkProxy</th> 
   <th align="center">Cglib</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">依赖</td> 
   <td align="center">被代理对象实现了接口（所有接口的方法数总和必须&gt;0[4]）</td> 
   <td align="center">引入asm、cglib jar ；不能是final类和方法</td> 
  </tr> 
  <tr> 
   <td align="center">原理</td> 
   <td align="center">反射，实现被代理对象接口的匿名内部类，通过InvocationHandler.invoke()包围被代理对象的方法</td> 
   <td align="center">引入asm、cglib jar，代理类实现MethodInterceptor，通过底层重写字节码来实现</td> 
  </tr> 
  <tr> 
   <td align="center">效率</td> 
   <td align="center">创建快，运行慢(见下方说明2)</td> 
   <td align="center">创建慢，运行快</td> 
  </tr> 
 </tbody> 
</table>

> **说明：** Cglib是如何修改字节码，从代码上是看不出来的。使用的是ASM技术，修改class文件，可以自行查阅。 JDK1.8及以后，JdkProxy的运行速度已经比Cglib快了（之前则是慢于Cglib）。

4、关于org.apoalliance.intercept.MethodInterceptor

class CommonInterceptor implements MethodInterceptor { 
          @Override
          public Object invoke(MethodInvocation invocation) throws Throwable { 
                try { 
                       // 拦截器内部逻辑
                      result = invoication.proceed();
                catch(Throwable e) { 
                      // 异常处理
                }
                return result;
          }
    }

声明代理链

@Configuration
    public class InterceptorConfig { 
    
          @Bean
          public CommonInterceptor serviceInterceptor() { 
                CommonInterceptor bean = new CommonInterceptor();
                return bean;
          }
    
          // 代理名称后缀为servie的实现类
          @Bean
          public BeanNameAutoProxyCreator servieBeanNameAutoProxyCreator() { 
                BeanNameAutoProxyCreator creator = new BeanNameAutoProxyCreator();
                creator.setName("*ServieImpl");
                creator.setInterceptorNames("serviceInterceptor");
                creator.setProxyTargetClass(true);
                return creator;
          }
    }

查了一些资料，apoalliance包下只是aop的接口规范，不是具体的实现，不要把这里的MethodInterceptor和cglib的MethodInterceptor搞混。

**（4） 构造方法注入和设值注入的区别**

> 注：设值注入指的是通过setter注入。

换一种说法：

1.  如果只设置基本类型(int、long等)的值，建议设置默认值而不是通过任何一种注入完成
2.  构造注入不支持大部分的依赖注入。构造注入仅在创建时执行，设值注入的值在后续也可以变化。
3.  设值注入可以支持尚未完整的被依赖的对象，构造注入则不行。可以通过构造注入决定依赖关系，因此如果依赖关系不会发生变更也可以选择依赖注入。

**（5）ApplicationContext事件**

可以通过实现ApplicationEvent类和ApplicationListener接口，进行ApplicationContext的事件处理。这是标准的发送者-监听者的模型，可以用来处理业务逻辑，将代码解耦。  
但是，发送和接收实际上是同步的，如果有事务，会在同一个事务内，并不能作为异步处理机制。

## 3. SpringBoot ##

**（1）SpringBoot的关键注解**

所谓核心注解，这里指的是相对Spring本身新增的一些注解，来看看它们有什么作用。  
恰好这里提到的注解，都可以打在SpringBoot的启动类（不限于启动类），用下面的代码片段来进行说明。  
**代码示例：**

package com.example.demo;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.Import;
    import org.springframework.context.annotation.PropertySource;
    
    @PropertySource(value = "classpath:application.properties")
    @MapperScan("com.example.demo.dal")
    @SpringBootApplication(scanBasePackages = { "com.example.demo"})
    @Import({ DemoConfig1.class, DemoConfig2.class,})
    public class DemoApplication { 
       public static void main(String[] args) { 
       	SpringApplication.run(DemoApplication.class, args);
       }
    }

**（2） @PropertySource**

从指定的文件读取变量。示例代码会从resource目录下读取application.properties变量的值。文件的格式如下，既可以用常量，也可以用变量替换，来对不同环境的值作区分。

name=value
    env.name=$env.value

如何使用这个值？在要使用的地方获取即可。

@PropertySource(value = "classpath:application.properties")
    class TestClass { 
    	@Resource
    	private Environment environment;
    
          @Test
          public void test() { 
                String value = environment.getProperty("name"));
          }
    }

**（3） 与@Value配合使用**

使用@Value可以把配置文件的值直接注入到成员变量中。

@PropertySource("classpath:application.properties")
    public class PropertyConfig { 
        @Value("${name}")
        private String value;
         ...
    }

**（4）通过@Import引用**

在（1）的示例代码中，如果类上没有@PropertySource，但DemoConfig1或DemoConfig2中有@PropertySource，通过@Import可以将它们加载的变量也读出来。

**（5）properties和.yml配置文件**

@PropertySource只能导入.properties配置文件里的内容，对于.yml是不支持的。看了一些文章，得出结论是yml文件是不需要注解就能导入，但是需要路径。  
Springboot有两种核心配置文件，application和bootstrap，都可以用properties或yml格式。区别在于bootstrap比application优先加载，并且不可覆盖。

**（6）@MapperScan**

这实际上是一个mybatis注解，作用是为指定路径下的DAO接口，通过sqlmapping.xml文件，生成实现类。

**（7）@SpringBootApplication**

@SpringBootApplication是由多个注解组合成的。源码如下：

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan(excludeFilters = {  @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
    public @interface SpringBootApplication { 
          // 略
    }

**简单介绍一下这些注解：**

1.元注解

最上面四行都是元注解。回忆一下它们的作用：

*  @Target 注解可以用在哪。TYPE表示类型，如类、接口、枚举
 *  @Retention 注解的保留时间期限。只有RUNTIME类型可以在运行时通过反射获取其值
 *  @Documented 该注解在生成javadoc文档时是否保留
 *  @Inherited 被注解的元素，是否具有继承性，如子类可以继承父类的注解而不必显式的写下来。

2.@SpringBootConfiguration

标注这是一个SpringBoot的配置类，和@Configuration功能是相通的，从源码也可以看出它直接使用了@Configuration。  
回忆一下，@Configuration注解的作用是，整合相关的@Bean来实现实例的声明，用以代替xml的形式。

3.@EnableAutoConfiguration

这个注解是实现自动化配置的核心注解，定义如下：

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import(AutoConfigurationImportSelector.class)
    public @interface EnableAutoConfiguration { 
          // 略
    }

借助@Import引入的AutoConfigurationImportSelector，SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IoC容器。具体的细节这里不展开了，简单提一句，加载的是指定的配置文件中META-INF/spring.factories的配置。

4.@ComponentScan

扫描@Service、@Repository、@Component、@Controller等标注的类，创建bean。  
可以设置扫描范围，决定类哪些生成bean，哪些类不生成。

5.@Import

将外部资源（bean、@Configuration配置类）导入到当前IOC容器中。  
使用@Import便可以实例化引用的jar中定义的bean了。

## 4、Starter ##

指的是在依赖中引用的各种starter包。starter可以看作是“依赖jar+配置”打包的结果，目的是降低开发者引入组件的成本，不用自己梳理依赖、编写配置文件。  
starter遵循“约定大于配置”的原则，使用的组件的配置大部分都有默认值，不声明也可以直接用。

创建一个Spring boot的简易步骤：

1.  创建maven项目
2.  创建proterties类来保存配置信息
3.  编写业务功能类（包含会实例化为bean的类）
4.  编写Configuration类，定义bean
5.  在resources 文件夹下新建目录 META-INF，在目录中新建 spring.factories 文件，并且在  
    spring.factories 中配置AutoConfiguration
6.  打包

## 5、war包 ##

**（1）和jar包的区别**

*  jar 把类和相关的资源封装
 *  war 代表了一个可部署的Web应用程序

（2）SpringBoot项目打war包部署  
通用步骤如下，其中1可能需要移除内嵌tomcat，2有其他形式，因为我工作时都是拿线程脚本打包的，没有实际操作过，下面步骤仅供参考。

*  pom.xml修改为按war打包
 *  修改main入口方法，继承一个SpringBootServletInitializer类，并且覆盖configure方法
 *  maven打包
 *  复制到tomcat路径下（tomcat需要预先配置），使用startup启动

## 6、Springboot面试题补充 ##

（1） 使用Springboot的两种方式

1.  继承spring-boot-starter-parent项目

<parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
         <version>1.5.6.RELEASE</version>
    </parent>

1.  导入spring-boot-dependencies项目依赖

<dependencyManagement>
          <dependencies>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-dependencies</artifactId>
                    <version>1.5.6.RELEASE</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
          </dependencies>
    </dependencyManagement>

1.  SpringBoot 需要独立的容器运行吗？

可以不需要，内置了 Tomcat/Jetty等容器。  
如何使用Jetty？排除掉Tomcat依赖并引入Jetty，并更改一些application配置。

1.  运行 SpringBoot 有哪几种方式？

打包用命令或者放到容器中运行  
用 Maven/ Gradle 插件运行  
直接执行 main 方法运行

1.  SpringBoot启动时运行特定代码的方式

Bean实现接口 ApplicationRunner或者CommandLineRunner即可。

1.  SpringBoot实现热部署有哪几种方式？  
    主要有两种：  
    Spring Loaded —— 引用依赖（maven plugin）。对于注解和xml变动无法感知需要重启；  
    Spring-boot-devtools —— 引用依赖、更改配置（可选）、启动idea的自动编译。注意生产环境插件可能导致gc。
2.  Spring Boot 可以兼容老 Spring 项目吗，如何做？  
    可以兼容，使用 @ImportResource 注解导入老 Spring 项目配置文件。

## 7、 SpringBoot启动原理 ##

SpringBoot的启动入口在main方法的SpringApplication.run(XXXApplication.class, args)处。  
启动图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ1MjcwNjY3_size_16_color_FFFFFF_t_70_pic_center]  
简单总结下：

*  注册各种环境变量配置
 *  注册各种工厂
 *  注册各种监听器
 *  创建上下文，初始化各种bean

> 其实知识都是学来的，多学些就行，工作中能学到的跟多，但是首先得有个好的工作，有个好的工作机会，而有个好的工作，又离不开技术的高低，技术的高低又得靠学习来提升，所以这都是相辅相成的，不给自己投资就得不到高的回报。

我这整理有很多的Java面试题，也有Java的学习资料和途径，有需要的可以[点击进入，暗号：cszq][cszq]，可以免费提供！  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ1MjcwNjY3_size_16_color_FFFFFF_t_70_pic_center 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ1MjcwNjY3_size_16_color_FFFFFF_t_70_pic_center 2]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ1MjcwNjY3_size_1_color_FFFFFF_t_70_pic_center]: /images/20221123/18ed2ce2d8cf42fbb8eff5720cce06e1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ1MjcwNjY3_size_1_color_FFFFFF_t_70_pic_center 1]: /images/20221123/1d877405b9b641b0a001f6578923b7e8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ1MjcwNjY3_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/1f0a4ed8f7aa472183ed7306b94de62e.png
[cszq]: https://jq.qq.com/?_wv=1027&k=gg6TrvbI
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ1MjcwNjY3_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/872bf5ec3a314e27835861a90042d2ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ1MjcwNjY3_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/f6f90d1631f1498da13f86866ead9e80.png