如何寻115资源

作者：aa115tt

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

(资料图)

2. Spring

AOP术语

通知Advice —— 切面要做什么，何时执行。何时，包括方法调用前、方法调用后、方法成功调用后、方法调用抛异常后、环绕(Around)。环绕允许提供一些需要跨越方法调用前后的功能，如计算调用耗时。

连接点Joinpoint —— 应用执行时能插入切面的点。实际上是一个逻辑概念，不体现在配置中。

切点Pointcut —— 执行通知的具体的连接点。

切面Aspect —— 通知+切点

引入Introduction —— 允许为类添加新的方法或属性。（个人理解即应用使用切面中的方法和属性，就好像这些方法和属性是原生的一样。可以参考<aop:declare-parents>元素）

织入Weaving —— 将切面应用到目标对象创建新的代理对象的过程，Spring使用的是运行时。编译期和类加载时是其他的方式。

Bean的生命周期

虽然被称为生命周期，实际上指的是bean在初始化、回收期间调用了哪些方法。如果只看《Spring实战》，可以看到类似下面的图（图源：参考文献[3]）

具体哪一步做了什么？其实这些方法都是可选的，自定义的bean可以实现，也可以不实现，实现里写什么似乎都没问题，参考文献[3]中的测试代码展示了这些方法在bean生命周期中的执行顺序。

但是对于Spring框架的bean，就有必要的用途了。这里没有深入研究，有兴趣可以自行读源码。

Cglib和JdkProxy

与Spring的关系

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

默认使用JdkProxy

对于被代理对象没有实现任何接口，使用Cglib

可以强制指定使用Cglib。

这样就可以解释为什么有的bean实现了接口，有的没有，但是在同一个工程中可以并存了。

示例代码

本节代码改写自参考文献[5]。

//用户管理接口

public interface UserManager {

//新增用户抽象方法

void addUser(String userName,String password);

//删除用户抽象方法

void delUser(String userName);

}

//用户管理实现类,实现用户管理接口

public class UserManagerImpl implements UserManager{

@Override

public void addUser(String userName) {

("调用了新增的方法！");

("传入参数为 userName: "+userName+" password: "+password);

}

@Override

public void delUser(String userName) {

("调用了删除的方法！");

("传入参数为 userName: "+userName);

}   

}

import ;

import ;

import ;

import ;

import ;

//JDK动态代理实现InvocationHandler接口

public class JdkProxy implements InvocationHandler {

private Object target ;//需要代理的目标对象

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

("JDK动态代理，监听开始！");

Object result = (target, args);

("JDK动态代理，监听结束！");

return result;

}

//定义获取代理对象方法

// 因为只是在main()里测试，声明为private了 

private Object getJDKProxy(Object targetObject){

= targetObject;

return (().getClassLoader(), ().getInterfaces(), this);

}

public static void main(String[] args) {

JdkProxy jdkProxy = new JdkProxy();

UserManager user = (UserManager) (new UserManagerImpl());//获取代理对象

("admin");

}   

}

import ;

import ;

import ;

import ;

import ;

import ;

//Cglib动态代理，实现MethodInterceptor接口

public class CglibProxy implements MethodInterceptor {

private Object target;//需要代理的目标对象

//重写拦截方法

@Override

public Object intercept(Object obj, Method method, Object[] arr, MethodProxy proxy) throws Throwable {

("Cglib动态代理，监听开始！");

Object invoke = (target, arr);//方法执行，参数：target 目标对象 arr参数数组

("Cglib动态代理，监听结束！");

return invoke;

}

//定义获取代理对象方法

public Object getCglibProxy(Object objectTarget){

//为目标对象target赋值

= objectTarget;

Enhancer enhancer = new Enhancer();

//设置父类,因为Cglib是针对指定的类生成一个子类，所以需要指定父类

(());

(this);// 设置回调 

Object result = ();//创建并返回代理对象

return result;

}

public static void main(String[] args) {

CglibProxy cglib = new CglibProxy();

UserManager user =  (UserManager) (new UserManagerImpl());

("admin");

}

}

比较

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

JdkProxy Cglib

依赖 被代理对象实现了接口（所有接口的方法数总和必须>0[4]） 引入asm、cglib jar ；不能是final类和方法

原理 反射，实现被代理对象接口的匿名内部类，通过()包围被代理对象的方法 引入asm、cglib jar，代理类实现MethodInterceptor，通过底层重写字节码来实现

效率 创建快，运行慢(见下方说明2) 创建慢，运行快

说明

Cglib是如何修改字节码，从代码上是看不出来的。使用的是ASM技术，修改class文件，可以自行查阅。

及以后，JdkProxy的运行速度已经比Cglib快了（之前则是慢于Cglib），测试代码可见参考文献[6]。

关于

我读了一下之前所用的日志拦截器源码，发现其实现的是这节标题的接口：

class CommonInterceptor implements MethodInterceptor {

@Override

public Object invoke(MethodInvocation invocation) throws Throwable {

try {

// 拦截器内部逻辑

result = ();

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();

("*ServieImpl");

("serviceInterceptor");

(true);

return creator;

}

}

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

构造方法注入和设值注入的区别

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

之前看参考文献[7]，感觉很难懂，试着改换了一种说法：

如果只设置基本类型(int、long等)的值，建议设置默认值而不是通过任何一种注入完成

构造注入不支持大部分的依赖注入。构造注入仅在创建时执行，设值注入的值在后续也可以变化。

设值注入可以支持尚未完整的被依赖的对象，构造注入则不行。可以通过构造注入决定依赖关系，因此如果依赖关系不会发生变更也可以选择依赖注入。

ApplicationContext事件

可以通过实现ApplicationEvent类和ApplicationListener接口，进行ApplicationContext的事件处理。这是标准的发送者-监听者的模型，可以用来处理业务逻辑，将代码解耦。

但是，发送和接收实际上是同步的，如果有事务，会在同一个事务内，并不能作为异步处理机制[8]。

示例代码见参考文献[9]。

3. SpringBoot

注：工作中我对SpringBoot是偏应用的，研究并不是很深入。

如何快速搭建一个SpringBoot项目

见参考文献[10]。实际的过程是借助Spring Initializer这个网络应用程序来生成SpringBoot项目。

SpringBoot的关键注解

所谓核心注解，这里指的是相对Spring本身新增的一些注解，来看看它们有什么作用。

恰好这里提到的注解，都可以打在SpringBoot的启动类（不限于启动类），用下面的代码片段来进行说明。

代码示例

package ;

import ;

import ;

import ;

import ;

import ;

@PropertySource(value = "classpath:")

@MapperScan("")

@SpringBootApplication(scanBasePackages = {""})

@Import({, ,})

public class DemoApplication {

public static void main(String[] args) {

(, args);

}

}

@PropertySource

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

name=value

=$

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

@PropertySource(value = "classpath:")

class TestClass {

@Resource

private Environment environment;

@Test

public void test() {

String value = ("name"));

}

}

与@Value配合使用

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

@PropertySource("classpath:")

public class PropertyConfig {

@Value("${name}")

private String value;

...

}

通过@Import引用

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

@Import的作用在下文会继续介绍。

.properties和.yml配置文件

@PropertySource只能导入.properties配置文件里的内容，对于.yml是不支持的。看了一些文章，得出结论是yml文件是不需要注解就能导入，但是需要路径。

Springboot有两种核心配置文件，application和bootstrap，都可以用properties或yml格式。区别在于bootstrap比application优先加载，并且不可覆盖。

@MapperScan

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

@SpringBootApplication

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

@Target()

@Retention()

@Documented

@Inherited

@SpringBootConfiguration

@EnableAutoConfiguration

@ComponentScan(excludeFilters = { @Filter(type = , classes = ),

@Filter(type = , classes = ) })

public @interface SpringBootApplication {

// 略

}

简单介绍一下这些注解。

#### 元注解

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

* @Target 注解可以用在哪。TYPE表示类型，如类、接口、枚举

* @Retention 注解的保留时间期限。只有RUNTIME类型可以在运行时通过反射获取其值

* @Documented 该注解在生成javadoc文档时是否保留

* @Inherited 被注解的元素，是否具有继承性，如子类可以继承父类的注解而不必显式的写下来。

#### @SpringBootConfiguration

标注这是一个SpringBoot的配置类，和@Configuration功能是相通的，从源码也可以看出它直接使用了@Configuration。

#### @EnableAutoConfiguration

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

```java

@Target()

@Retention()

@Documented

@Inherited

@AutoConfigurationPackage

@Import()

public @interface EnableAutoConfiguration {

// 略

}

借助@Import引入的AutoConfigurationImportSelector，SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IoC容器。具体的细节这里不展开了。

@ComponentScan

扫描@Service、@Repository、@Component、@Controller等标注的类，创建bean。

可以设置扫描范围，决定类哪些生成bean，哪些类不生成。

@Import

将外部资源（bean、@Configuration配置类）导入到当前IOC容器中。

使用@Import便可以实例化引用的jar中定义的bean了。

Starter

指的是在依赖中引用的各种starter包。starter可以看作是“依赖jar+配置”打包的结果，目的是降低开发者引入组件的成本，不用自己梳理依赖、编写配置文件。

starter遵循“约定大于配置”的原则，使用的组件的配置大部分都有默认值，不声明也可以直接用。

创建一个Spring boot的简易步骤（完整的可以看参考文献[14]）:

创建maven项目

创建proterties类来保存配置信息

编写业务功能类（包含会实例化为bean的类）

编写Configuration类，定义bean

在resources 文件夹下新建目录 META-INF，在目录中新建 文件，并且在 中配置AutoConfiguration

打包

war包

和jar包的区别

jar 把类和相关的资源封装

war 代表了一个可部署的Web应用程序

SpringBoot项目打war包部署

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

修改为按war打包

修改main入口方法，继承一个SpringBootServletInitializer类，并且覆盖configure方法

maven打包

复制到tomcat路径下（tomcat需要预先配置），使用startup启动

Springboot面试题补充

本节内容结合了参考文献[16]进行补充，上面提到的知识不再重复。

使用Springboot的两种方式

继承spring-boot-starter-parent项目

<parent>

<groupId></groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version></version>

</parent>

导入spring-boot-dependencies项目依赖

<dependencyManagement>

<dependencies>

<dependency>

<groupId></groupId>

<artifactId>spring-boot-dependencies</artifactId>

<version></version>

<type>pom</type>

<scope>import</scope>

</dependency>

</dependencies>

</dependencyManagement>

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

可以不需要，内置了 Tomcat/Jetty等容器。

如何使用Jetty？排除掉Tomcat依赖并引入Jetty，并更改一些application配置。两种容器的比较和替换方式见参考文献[17]。

运行 SpringBoot 有哪几种方式？

打包用命令或者放到容器中运行

用 Maven/ Gradle 插件运行

直接执行 main 方法运行

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

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

SpringBoot实现热部署有哪几种方式？

主要有两种

Spring Loaded —— 引用依赖（maven plugin）。对于注解和xml变动无法感知需要重启

Spring-boot-devtools —— 引用依赖、更改配置（可选）、启动idea的自动编译。注意生产环境插件可能导致gc

Spring Boot 可以兼容老 Spring 项目吗，如何做？

可以兼容，使用 @ImportResource 注解导入老 Spring 项目配置文件。

参考文献

-连接点和切点的区别

AOP术语：连接点和切点的区别。

3.深究Spring中Bean的生命周期

AOP代理用的到底是CGLIB还是JDK动态代理

5. Spring的两种动态代理：Jdk和Cglib 的区别和实现

6. Spring AOP中的JDK和CGLib动态代理哪个效率更高？

7. 经典面试题-构造方法注入和设值注入有什么区别？

8. Spring的ApplicationEvent

9. spring-第三篇之ApplicationContext的事件机制

10. 使用IDEA搭建一个简单的SpringBoot项目——详细过程

11. 浅析PropertySource 基本使用

12. JAVA核心知识点--元注解详解

13. 简单讲讲@SpringBootApplication

14. Spring Boot Starters

15. SpringBoot 打包成war

16. 吐血整理 20 道 Spring Boot 面试题，我经常拿来面试别人！

17. SpringBoot2使用Jetty容器（替换默认Tomcat）

作者：bili_28840997693 /read/cv9003907/ 出处：bilibili