spring配置和注解开发原理

合集下载

SpringBootApplication注解原理及代码详解

SpringBootApplication注解原理及代码详解1、SpringBoot 启动main()@SpringBootApplicationpublic class TomcatdebugApplication {public static void main(String[] args) {SpringApplication.run(TomcatdebugApplication.class, args);}}1.1 @SpringBootApplication 注解，其实主要是@ComponentScan,@EnableAutoConfiguration,@SpringBootConfiguration三个注解@ComponentScan 注解：spring⾥有四⼤注解：@Service,@Repository,@Component,@Controller⽤来定义⼀个bean.@ComponentScan注解就是⽤来⾃动扫描被这些注解标识的类，最终⽣成ioc容器⾥的bean．可以通过设置@ComponentScan　basePackages，includeFilters，excludeFilters属性来动态确定⾃动扫描范围，类型已经不扫描的类型．　默认情况下:它扫描所有类型，并且扫描范围是@ComponentScan注解所在配置类包及⼦包的类@SpringBootConfiguration 注解：@SpringBootConfiguration继承⾃@Configuration，⼆者功能也⼀致，标注当前类是配置类，并会将当前类内声明的⼀个或多个以@Bean注解标记的⽅法的实例纳⼊到spring容器中，并且实例名就是⽅法名。

demo 说明：（1）注⼊spring ioc bean@SpringBootConfigurationpublic class Config {@Beanpublic Map createMap(){Map map = new HashMap();map.put("username","gxz");map.put("age",27);return map;}}(2)调⽤：public static void main( String[] args ){//⽅式1 获取contextConfigurableApplicationContext context = SpringApplication.run(App.class, args);context.getBean(Runnable.class).run();context.getBean("createMap"); //注意这⾥直接获取到这个⽅法beanint age = (int) map.get("age");System.out.println("age=="+age);//⽅式2. 使⽤@Autowired注解，应⽤bean// @Autowired// Map createMap}@EnableAutoConfiguration 注解@EnableAutoConfiguration作⽤：从classpath中搜索所有的META-INF/spring.factories配置⽂件，然后将其中key为org.springframework.boot.autoconfigure.EnableAutoConfiguration的value加载到spring容器中。

spring MVC原理及配置

spring MVC原理及配置springmvc原理及配置springmvc原理及配置1.springmvc详述：springmvc就是spring提供更多的一个强悍而有效率的web框架。

借助注释，springmvc提供更多了几乎就是pojo的研发模式，使控制器的研发和测试更加直观。

这些控制器通常不轻易处置命令，而是将其委托给spring上下文中的其他bean，通过spring的倚赖转化成功能，这些bean被转化成至控制器中。

springmvc主要由dispatcherservlet、处理器映射、处理器(控制器)、视图解析器、视图组成。

他的两个核心是两个核心：处理器映射：选择使用哪个控制器来处理请求视图解析器：选择结果应该如何渲染通过以上两点，springmvc确保了如何挑选掌控处置命令和如何挑选视图展现出输入之间的松耦合。

2.springmvc运行原理这里写图片描述(2)找寻处理器：由dispatcherservlet控制器查阅一个或多个handlermapping，找出处置命令的controller。

(3)调用处理器：dispatcherservlet将请求提交到controller。

(4)(5)调用业务处置和回到结果：controller调用业务逻辑处置后，回到modelandview。

3.springmvc接口解释（1）dispatcherservlet接口：spring提供的前端控制器，所有的请求都有经过它来统一分发。

在dispatcherservlet将请求分发给springcontroller 之前，需要借助于spring提供的handlermapping定位到具体的controller。

（2）handlermappingUSB：能够完成客户请求到controller映射。

（3）controller接口：须要为mammalian用户处置上述命令，因此同时实现controllerUSB时，必须确保线程安全并且可以器重。

Spring中异步注解@Async的使用、原理及使用时可能导致的问题及解决方法

Spring中异步注解@Async的使⽤、原理及使⽤时可能导致的问题及解决⽅法前⾔其实最近都在研究事务相关的内容，之所以写这么⼀篇⽂章是因为前⾯写了⼀篇关于循环依赖的⽂章：《》然后，很多同学碰到了下⾯这个问题，添加了Spring提供的⼀个异步注解@Async循环依赖⽆法被解决了，下⾯是⼀些读者的留⾔跟群⾥同学碰到的问题：本着讲⼀个知识点就要讲明⽩、讲透彻的原则，我决定单独写⼀篇这样的⽂章对@Async这个注解做⼀下详细的介绍，这个注解带来的问题远远不⽌循环依赖这么简单，如果对它不够熟悉的话建议慎⽤。

⽂章要点@Async的基本使⽤这个注解的作⽤在于可以让被标注的⽅法异步执⾏，但是有两个前提条件配置类上添加@EnableAsync注解需要异步执⾏的⽅法的所在类由Spring管理需要异步执⾏的⽅法上添加了@Async注解我们通过⼀个Demo体会下这个注解的作⽤吧第⼀步，配置类上开启异步：@EnableAsync@Configuration@ComponentScan("com.dmz.spring.async")public class Config {}第⼆步，[code]@Component // 这个类本⾝要被Spring管理public class DmzAsyncService { @Async // 添加注解表⽰这@Component // 这个类本⾝要被Spring管理public class DmzAsyncService {@Async // 添加注解表⽰这个⽅法要异步执⾏public void testAsync(){try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("testAsync invoked");}}第三步，测试异步执⾏public class Main {public static void main(String[] args) {AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);DmzAsyncService bean = ac.getBean(DmzAsyncService.class);bean.testAsync();System.out.println("main函数执⾏完成");}}// 程序执⾏结果如下：// main函数执⾏完成// testAsync invoked通过上⾯的例⼦我们可以发现，DmzAsyncService中的testAsync⽅法是异步执⾏的，那么这背后的原理是什么呢？我们接着分析原理分析我们在分析某⼀个技术的时候，最重要的事情是，⼀定⼀定要找到代码的⼊⼝，像Spring这种都很明显，⼊⼝必定是在@EnableAsync这个注解上⾯，我们来看看这个注解⼲了啥事（本⽂基于5.2.x版本）@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented// 这⾥是重点，导⼊了⼀个ImportSelector@Import(AsyncConfigurationSelector.class)public @interface EnableAsync {// 这个配置可以让程序员配置需要被检查的注解，默认情况下检查的就是@Async注解Class<? extends Annotation> annotation() default Annotation.class;// 默认使⽤jdk代理boolean proxyTargetClass() default false;// 默认使⽤Spring AOPAdviceMode mode() default AdviceMode.PROXY;// 在后续分析我们会发现，这个注解实际往容器中添加了⼀个// AsyncAnnotationBeanPostProcessor，这个后置处理器实现了Ordered接⼝// 这个配置主要代表了AsyncAnnotationBeanPostProcessor执⾏的顺序int order() default Ordered.LOWEST_PRECEDENCE;}上⾯这个注解做的最重要的事情就是导⼊了⼀个AsyncConfigurationSelector，这个类的源码如下：public class AsyncConfigurationSelector extends AdviceModeImportSelector<EnableAsync> {private static final String ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME ="org.springframework.scheduling.aspectj.AspectJAsyncConfiguration";@Override@Nullablepublic String[] selectImports(AdviceMode adviceMode) {switch (adviceMode) {// 默认会使⽤SpringAOP进⾏代理case PROXY:return new String[] {ProxyAsyncConfiguration.class.getName()};case ASPECTJ:return new String[] {ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME};default:return null;}}}这个类的作⽤是像容器中注册了⼀个ProxyAsyncConfiguration，这个类的继承关系如下：我们先看下它的⽗类AbstractAsyncConfiguration，其源码如下：@Configurationpublic abstract class AbstractAsyncConfiguration implements ImportAware {@Nullableprotected AnnotationAttributes enableAsync;@Nullableprotected Supplier<Executor> executor;@Nullableprotected Supplier<AsyncUncaughtExceptionHandler> exceptionHandler;// 这⾥主要就是检查将其导⼊的类上是否有EnableAsync注解// 如果没有的话就报错@Overridepublic void setImportMetadata(AnnotationMetadata importMetadata) {this.enableAsync = AnnotationAttributes.fromMap(importMetadata.getAnnotationAttributes(EnableAsync.class.getName(), false));if (this.enableAsync == null) {throw new IllegalArgumentException("@EnableAsync is not present on importing class " + importMetadata.getClassName());}}// 将容器中配置的AsyncConfigurer注⼊// 异步执⾏嘛，所以我们可以配置使⽤的线程池// 另外也可以配置异常处理器@Autowired(required = false)void setConfigurers(Collection<AsyncConfigurer> configurers) {if (CollectionUtils.isEmpty(configurers)) {return;}if (configurers.size() > 1) {throw new IllegalStateException("Only one AsyncConfigurer may exist");}AsyncConfigurer configurer = configurers.iterator().next();this.executor = configurer::getAsyncExecutor;this.exceptionHandler = configurer::getAsyncUncaughtExceptionHandler;}}再来看看ProxyAsyncConfiguration这个类的源码@Configuration@Role(BeanDefinition.ROLE_INFRASTRUCTURE)public class ProxyAsyncConfiguration extends AbstractAsyncConfiguration {@Bean(name = TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME) @Role(BeanDefinition.ROLE_INFRASTRUCTURE)public AsyncAnnotationBeanPostProcessor asyncAdvisor() {AsyncAnnotationBeanPostProcessor bpp = new AsyncAnnotationBeanPostProcessor();// 将通过AsyncConfigurer配置好的线程池跟异常处理器设置到这个后置处理器中bpp.configure(this.executor, this.exceptionHandler);Class<? extends Annotation> customAsyncAnnotation = this.enableAsync.getClass("annotation"); if (customAsyncAnnotation != AnnotationUtils.getDefaultValue(EnableAsync.class, "annotation")) { bpp.setAsyncAnnotationType(customAsyncAnnotation);}bpp.setProxyTargetClass(this.enableAsync.getBoolean("proxyTargetClass"));bpp.setOrder(this.enableAsync.<Integer>getNumber("order"));return bpp;}}这个类本⾝是⼀个配置类，它的作⽤是向容器中添加⼀个AsyncAnnotationBeanPostProcessor。

springboot自动配置原理以及spring.factories文件的作用详解

springboot⾃动配置原理以及spring.factories⽂件的作⽤详解⽬录⼀、springboot ⾃动配置原理⼆、spring.factories⽂件的作⽤spring.factories 的妙⽤什么是 SPI 机制？Spring Boot 中的 SPI 机制Spring Factories 实现原理是什么？Spring Factories 在 Spring Boot 中的应⽤⼀、springboot ⾃动配置原理先说说我们⾃⼰的应⽤程序中Bean加⼊容器的办法：package com.ynunicom.dc.dingdingcontractapp;import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;/*** @author jinye.Bai*/@SpringBootApplication(scanBasePackages ={"com.ynunicom.dc.dingdingcontractapp"})public class DingdingContractAppApplication {public static void main(String[] args) {SpringApplication.run(DingdingContractAppApplication.class, args);}}我们在应⽤程序的⼊⼝设置了 @SpringBootApplication标签，默认情况下他会扫描所有次级⽬录。

如果增加了 scanBasePackages属性，就会扫描所有被指定的路径及其次级⽬录。

【SpringFramework】Spring入门教程（三）使用注解配置

【SpringFramework】Spring⼊门教程（三）使⽤注解配置本⽂主要介绍四个⽅⾯：(1) 注解版本IOC和DI(2) Spring纯注解(3) Spring测试(4) SpringJDBC - Spring对数据库的操作使⽤注解配置Spring⼊门说在前⾯学习基于注解的IoC配置，⼤家脑海⾥⾸先得有⼀个认知，即注解配置和xml配置要实现的功能都是⼀样的，都是要降低模块间的耦合度。

仅仅只是配置的形式不⼀样。

关于实际的开发中到底使⽤xml还是注解，每家公司有着不同的使⽤习惯。

所以这两种配置⽅式我们都需要掌握。

基于注解配置的⽅式也已经逐渐代替xml配置。

所以我们必须要掌握使⽤注解的⽅式配置Spring。

配置步骤注意：如果使⽤Eclipse需要先安装了STS插件，或者使⽤STS开发⼯具创建项⽬。

本⽂使⽤IDEA进⾏演⽰。

1.2.1. 第⼀步：拷贝必备jar包到⼯程的lib⽬录。

注意：在基于注解的配置中，我们还要多拷贝⼀个aop的jar包。

如下图：1.2.2. 第⼆步：在类的根路径下创建⼀个任意名称的xml⽂件（不能是中⽂）注意：基于注解整合时，Spring配置⽂件导⼊约束时需要多导⼊⼀个context命名空间下的约束。

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"></beans>1.2.3. 第⼆步：创建⼀个服务类创建⼀个测试的服务类，并且加⼊使⽤@Component注解，声明该类允许注⼊到Spring容器package org.cjw.service;import ponent;/*使⽤注解配置时，需要将Spring框架启动就创建对象的类表⽰为组件类表⽰组件类使⽤@Component注解*/@Componentpublic class CustomerService {public void save() {System.out.println("-保存数据-");}}1.2.4. 第四步在spring的配置⽂件加⼊扫描注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"><context:component-scan base-package="org.cjw" /></beans>1.2.5. 第五步：测试调⽤代码package org.cjw.test;import org.cjw.service.CustomerService;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class CustomerServiceTest {@Testpublic void testSave() {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");CustomerService customerService = context.getBean(CustomerService.class);customerService.save();}}--测试结果，如果可以调⽤服务⽅法，测试成功。

spring框架中@PostConstruct的实现原理

spring框架中@PostConstruct的实现原理在spring项⽬经常遇到@PostConstruct注解，⾸先介绍⼀下它的⽤途: 被注解的⽅法，在对象加载完依赖注⼊后执⾏。

此注解是在Java EE5规范中加⼊的，在Servlet⽣命周期中有⼀定作⽤，它通常都是⼀些初始化的操作，但初始化可能依赖于注⼊的其他组件，所以要等依赖全部加载完再执⾏。

与之对应的还有@PreDestroy，在对象消亡之前执⾏，原理差不多，这⾥不做过多介绍。

那么⾸先看下源码注释PostConstruct注释介绍总体概括如上，注意其中⼏个点1. 要在依赖加载后，对象使⽤前执⾏，⽽且只执⾏⼀次，原因在上⾯已经说了。

2. 所有⽀持依赖注⼊的类都要⽀持此⽅法。

⾸先，我们可以看到这个注解是在javax.annotation包下的，也就是java拓展包定义的注解，并不是spring定义的，但⾄于为什么不在java包下，是因为java语⾔的元⽼们认为这个东西并不是java核⼼需要的⼯具，因此就放到扩展包⾥（javax中的x就是extension的意思），⽽spring是⽀持依赖注⼊的，因此spring必须要⾃⼰来实现@PostConstruct的功能。

3. ⽂档中说⼀个类只能有⼀个⽅法加此注解，但实际测试中，我在⼀个类中多个⽅法加了此注解，并没有报错，⽽且都执⾏了，我⽤的是springboot框架。

再往下看，这个注解有⼀些使⽤条件，挑⼀些重点的说⼀下PostConstruct注释规则1. 除了拦截器这个特殊情况以外，其他情况都不允许有参数，否则spring框架会报IllegalStateException；⽽且返回值要是void，但实际也可以有返回值，⾄少不会报错，只会忽略2. ⽅法随便你⽤什么权限来修饰，public、protected、private都可以，反正功能是由反射来实现3. ⽅法不可以是static的，但可以是final的所以，综上所述，在spring项⽬中，在⼀个bean的初始化过程中，⽅法执⾏先后顺序为Constructor > @Autowired > @PostConstruct先执⾏完构造⽅法，再注⼊依赖，最后执⾏初始化操作，所以这个注解就避免了⼀些需要在构造⽅法⾥使⽤依赖组件的尴尬。

Spring技术内幕：深入解析Spring架构与设计原理

Spring技术内幕深入解析Spring架构与设计原理（一）引子缘起已经很久没有写帖子了，现在总算是有点时间写些东西，也算是对自己的一个记录吧。

刚刚完成了一个软件产品，从概念到运营都弄了一下，正在推广当中，虽然还没有能够达到盈亏平衡，但是这个过程，对自己也算是一种历练。

先不管结果如何，好呆走过这么一遭了。

我打算用这个帖子，把自己在这个过程中的一些心得，特别是对Spring新的理解，记录下来。

使用这个帖子的标题，持续下来。

简单来说，自己的软件产品是一个基于互联网的SaaS协同软件平台,操作简单，支持流程定义，管理和多种客户端 -像短信，MSN，智能手机什么的（我这里就不多做什么广告了），也有一个企业版的版本，使用的技术框架是Hibernate + Spring + Wicket，下面是Linux和MySQL，还有云计算的平台的使用，以支持其扩展性，虽然现在还没有可扩展性的需求，但似乎不难从SaaS上，就会想到云计算, 其实，它们真的是天生的一对！关于云计算，自己对这个技术很感兴趣，觉得和开源软件的结合，是很有意思的，因为它们都有基于服务的基因，在云计算平台的使用上，也有一些初步的实践。

云计算是一个很有意思的话题，但在这里主要是想谈Spring，所以对云计算，这里就先不多说了，但非常欢迎有兴趣的朋友和一起另外找地方讨论！回到正题，在我自己的产品中，其中除了Wicket和云计算外，其他都是大家非常熟知的了，像Hibernate, Spring, MySQL什么的。

在这个过程中，发现自己对一些技术点也有了新的认识，最有体会的是Spring。

当然，在这个过程中，更大的收获是对产品开发整个过程的认识，在这点上，真是一言难尽........回到自己还算了解的Spring, 这次我使用的是3.0的代码，所以，有机会也把这些代码读了几遍，比原来的理解要加深了许多，也发现了不少和2.0代码不同的地方，以及自己一些对 Spring的新的理解，这些，就让我就用这个帖子系列，给自己总结一下，也算是对自己以前的那个代码分析的帖子做一个新的交代吧。

spring原理和实现机制

spring原理和实现机制Spring框架是一个开源的应用程序框架，它提供了一种简单的方法来构建基于Java的企业级应用程序。

Spring框架的原理和实现机制主要包括：1. 控制反转（IoC）：Spring使用控制反转（Inversion of Control，IoC）来管理应用程序中的对象。

传统的应用程序中，对象的创建和依赖关系管理是由程序员来实现的，而在Spring 中，对象的创建和管理工作由容器来完成。

容器会在应用程序启动时创建对象，并通过依赖注入的方式将对象之间的依赖关系注入到相应的对象中。

2. 依赖注入（DI）：依赖注入是Spring框架的核心机制之一。

它指的是容器在创建对象时，自动将其所依赖的其他对象注入进来。

通过依赖注入，对象之间的解耦程度大大提高，使得应用程序更加灵活、可扩展和可维护。

3. 面向切面编程（AOP）：Spring框架通过面向切面编程（Aspect-Oriented Programming，AOP）来实现横切关注点的模块化。

AOP可以将应用程序的核心逻辑（称为核心关注点）与横切关注点（如日志、事务管理等）分离开来，并通过切面来统一管理这些横切关注点。

4. 核心容器：Spring框架的核心是其容器（Container）。

容器使用BeanFactory接口作为底层容器的基础，并提供了ApplicationContext接口作为更高级的容器接口。

容器负责创建和管理应用程序中的对象，并提供了丰富的配置和管理功能。

5. 层次化的模块化架构：Spring的模块化架构使得开发者可以根据自己的需要选择使用不同的模块。

例如，Spring的核心模块包括IoC容器、AOP框架和BeanFactory等，而其他模块如Spring MVC、Spring Data等则提供了特定领域的解决方案。

6. 轻量级与非侵入性：Spring框架的设计理念是轻量级和非侵入性的。

它不依赖于特定的编程模型，可以与其他技术和框架无缝集成。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

1、Spring是一个开源、轻量级框架（轻量级是指依赖的东西少）
2、Spring核心控制反转(IoC)和面向切面(AOP)。

——AOP：面向切面编程，扩展功能时不用修改源代码
——IOC：创建对象不再是自己new出来，而是交给spring容器管理
3、Spring希望为企业应用提供一站式（one-stopshop）的解决方案。

一站式：从web层到访问数据库层都有相应解决方案。

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
对象的创建交给spring管理(基于配置的方式实现、基于注解的方式实现)
IOC底层原理：Xml配置、dom4j解析xml、工厂设计模式、反射
工厂模式：将对象的创建交给工厂，使用时调用工厂方法来获取。

A需要B时，不是直接创建B，而是通过C的方法来获取，C的方法用来创建B。

注解方式原理：
Spring整合web框架原理
1、把加载配置文件和创建对象的过程，在服务器启动的时候完成。

2、用监听器实现
Spring注解：
————注解是代码里面的特殊标签，使用注解可以完成一定功能；
注解写法@注解名（属性名称=属性值）；注解可以用在类上、方法上、属性上。

注解使用：
1、在对应类上加上注解，标明该类的创建交给spring来管理。

2、开启注解扫描功能，要指明扫描哪些包。

3、如果要为属性注入，则在属性上使用@autowired注解
AOP概念：
面向切面编程，扩展功能而不用修改源代码，采用横向抽取机制，取代了传统的纵向继承。

传统的纵向继承，耦合度太高
AOP底层使用动态代理实现：a. 如果是有接口的情况，使用动态代理创建接口实现类代理对象，b.如果没有接口，使用动态代理创建类的子类的代理对象。

AOP操作术语：
连接点（Joinpoint）：类里面哪些方法可以被增强（扩展功能），这些方法就称为连接点。

切入点(Pointcut)：在类里面有很多方法可以被增强，但是实际开发只需要增强几个方法，那么实际被增强的方法称为切入点。

通知/增强（Advice）:实际扩展的功能代码，比如在插入数据（对应insert()方法）时增加写日志操作（对应wirtelog()方法），这个写日志操作就被称为增强。

前置通知：在insert方法执行前执行
后置通知：在insert方法执行之后执行
异常通知：在insert方法执行出现异常时执行
最终通知：在insert方法的后置通知执行结束后执行
环绕通知：在insert方法执行前和执行后执行
切面（Aspect）：把需要增强的方法应用到具体的方法上的过程，称为切面。

在spring里面进行AOP操作使用的是aspectj来实现的，aspectj并不是spring的一部分，spring2.0后增加了对aspectj的支持。

使用aspectj实现AOP有两种方式：基于aspectj的xml配置，基于aspectj的注解方式。

AOP操作准备：
1、除了导入基本jar包外，还需要导入aop相关jar包（maven依赖）
2、创建spring核心配置文件，导入aop约束。

3、使用execution函数，配置切入点
切入点：实际需要增强的方法。

表达式写法：execution（<访问修饰符>？<返回类型><方法名>（<参数>）<异常>）例：(1)execution（* 增强方法全路径(包名.类名.方法名(..)))）→对类中指定方法增强
(2)execution（* 包名.类名.*(..)) →对类中所有方法增强
(3)execution（* *.*(..)) →对所有类中所有方法增强
4、在spring核心配置文件中配置切入点所对应的类和增强类
5、配置aop操作配置切入点；配置切面(把增强用到对应切入点上)
6、然后调用切入点对应的方法，即可实现增强方法发调用。

环绕通知：
注解方式实现AOP
1、创建对象，用注解方式标注对应类即可。

2、开启aop操作（配置，或者用注解）
3、在增强的类上使用注解
→在对应类上加@Aspect
→在增强方法上使用注解完成增强配置
4、调用被增强方法即可实现。