Spring
Posted 这一生关于你的风景
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring相关的知识，希望对你有一定的参考价值。
二、 Spring
1. Spring 简介
1. Spring 框架是开源的、轻量级的、最受欢迎的企业级 Java 应用程序开发框架，它最初是由 Rod Johnson 编写的，并且于 2003 年 6 月首次在 Apache 2.0 许可下发布
2. Spring 框架的目标是使 J2EE 开发变得更容易
3. Spring 框架的几大核心功能：
1）IoC/DI
a. 控制反转（IoC，即 Inversion of Control）是一个通用的概念，依赖注入（DI，即 Dependency Injection）仅仅是控制反转的一个具体的例子
b. 当类 A 中需要依赖另一个类对象 B 时，将类 B 通过 IoC 注入到类 A 中的过程就叫依赖注入
2）AOP（Aspect Oriented Programming）
3）Spring 事务管理：编程式和声明式事务管理
4. Spring 环境搭建
1）导入 jar 包：四个核心包（beans/context/core/expression），一个日志包（commons-logging）
a. 下载地址：https://repo.spring.io/release/org/springframework/spring/
b. 将 spring-beans.jar、spring-context.jar、spring-core.jar、spring-expression.jar、commons-logging.jar 拷贝到 WEB-INF/lib
2）在 src 下新建 applicationContext.xml
a. 文件名称和路径自定义
b. applicationContext.xml 配置的信息最终存储到 ApplicationContext 容器中
c. Spring 对于基于 XML 的配置，Spring 2.0 以后使用 Schema 的格式，使得不同类型的配置拥有了自己的命名空间，使配置文件更具扩展性
d. Schema 文件扩展名为 *.xsd，每次引入一个 *.xsd 文件都对应一个 namespace(xmlns)
e. 通过 <bean> 标签创建对象，默认配置文件被加载时就创建对象
3）配置 web.xml，Tomcat 启动时加载 Spring 配置文件：
<web-app>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
</web-app>
5. Spring 框架体系结构如下图所示
1）Test：支持对具有 JUnit 或 TestNG 框架的 Spring 组件的测试
2）Core Container：核心容器，是 Spring 启动的最基本条件
a. Beans：提供了 BeanFactory
b. Core：提供了框架的基本组成部分，包括 IoC 和依赖注入功能
c. Context：获取外部资源和管理注解等。ApplicationContext 接口是 Context 模块的焦点
d. SpEl（Spring Expression Language）：提供了强大的表达式语言
3）AOP：提供了面向切面的编程实现
4）Aspects：提供了与 AspectJ 的集成
5）Data Access/Integration：Spring 封装数据访问层相关内容
a. JDBC：Spring 对 JDBC 封装后的代码
b. ORM（Object Relational Mapping）：封装了持久层框架的代码，例如 Hibernate
c. OXM（Object XML Mapping）：提供了对 OXM 实现的支持，比如 XML Beans 等
d. JMS（Java Message Service）：包含生产（produce）和消费（consume）消息的功能
e. Transactions：对特殊接口实现类及所有的 POJO 支持编程式和声明式事务管理。（注：编程式事务需要自己写 beginTransaction()、commit()、rollback()等事务管理方法，声明式事务是通过注解或配置由 Spring 自动处理，编程式事务粒度更细）
6）Web：提供面向 Web 的基本功能和面向 Web 的应用上下文，比如多部分（multipart）文件上传功能、使用 Servlet 监听器初始化 IoC 容器等。它还包括 HTTP 客户端以及 Spring 远程调用中与 Web 相关的部分
2. Spring XML 配置文件
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd" default-autowire="byName"> <!-- 注解扫描 --> <context:component-scan base-package="com.ncdx.service.impl"></context:component-scan> <!-- 加载属性文件 --> <context:property-placeholder location="classpath:db.properties"></context:property-placeholder> <!-- 数据源 --> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="${mysqlDriver}"></property> <property name="url" value="${mysqlURL}"></property> <property name="username" value="${mysqlUser}"></property> <property name="password" value="${mysqlPwd}"></property> </bean> <!-- SqlSessionFactory创建 --> <bean id="factory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"></property> <property name="typeAliasesPackage" value="com.ncdx.pojo"></property> </bean> <!-- Mapper扫描器 --> <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <property name="basePackage" value="com.ncdx.mapper"></property> <property name="sqlSessionFactoryBeanName" value="factory"></property> </bean> <!-- 事务管理器 --> <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"></property> </bean> <tx:advice id="txAdvice" transaction-manager="txManager"> <tx:attributes> <tx:method name="ins*"/> <tx:method name="del*"/> <tx:method name="upd*"/> <tx:method name="*" read-only="true"/> </tx:attributes> </tx:advice> <!-- 配置aop --> <aop:config> <aop:pointcut expression="execution(* com.ncdx.service.impl.*.*(..))" id="mypoint"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="mypoint"/> </aop:config> </beans>
3. Spring 容器
1. Spring IoC 容器是具有依赖注入功能的容器，它负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖，并管理它们的整个生命周期从创建到销毁。这些对象被称为 Spring Beans
2. 通常 new 一个实例，控制权由程序员控制，而"控制反转"是指 new 实例工作不由程序员来做而是交给 Spring 容器来做。在 Spring 中 BeanFactory 是 IOC 容器的实际代表者
3. Spring 提供了以下两种不同类型的容器：
1）BeanFactory 容器
a. 它是最简单的容器，给 DI 提供了基本的支持。该容器由 org.springframework.beans.factory.BeanFactory 接口定义
b. 在 Spring 中，有大量对 BeanFactory 接口的实现。其中，最常被使用的是 XmlBeanFactory 类
XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResourc("beans.xml"));
People peo = (People) factory.getBean("peo");
2）ApplicationContext 容器
a. ApplicationContext 是 BeanFactory 的子接口，也被称为 Spring 上下文。该容器由 org.springframework.context.ApplicationContext 接口定义
b. 它包含了 BeanFactory 所有的功能，增加了企业所需要的功能，比如，从属性文件中解析文本信息和将事件传递给所指定的监听器。一般情况下，相对于 BeanFactory，ApplicationContext 会更加优秀
c. 当然，BeanFactory 仍可以在轻量级应用中使用，比如在资源宝贵的移动设备或者基于 applet 的应用程序中
d. 最常被使用的 ApplicationContext 接口实现：
① ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
从 XML 文件中加载已被定义的 bean。不需要提供 XML 文件的完整路径，只需正确配置 CLASSPATH 环境变量即可
② ApplicationContext ac = new FileSystemXmlApplicationContext("D:/workSpace/spring/src/applicationContext.xml");
从 XML 文件中加载已被定义的 bean。需要提供给 XML 文件的完整路径
③ ApplicationContext ac = new XmlWebApplicationContext();
无参数，在一个 web 应用程序的范围内加载在 XML 文件中已被定义的 bean
4. Spring Bean
1. Bean 是一个被实例化，组装，并通过 Spring IoC 容器所管理的对象。这些 bean 是由配置元数据创建的
2. Bean 的生命周期可以表达为：Bean的定义 —— Bean的初始化 —— Bean的使用 —— Bean的销毁
2. 每个 bean 都有如下属性：
1）id：在命名空间中唯一的标识符
2）class：这个属性是强制性的，指定创建该 bean 的 Java 类
3）autowire="default/no/byName/byType"：自动装配，默认为 default
4）scope：指定由该 bean 定义创建的对象的作用域
a. singleton：默认值，在 spring IoC 容器仅存在一个 Bean 实例，Bean 以单例方式存在
单例类型，在创建启动容器时就同时自动创建了一个 bean 的对象，不管你是否使用，它都存在了，每次获取到的对象都是同一个对象
b. prototype：每次从容器中调用 Bean 时，都返回一个新的实例，即每次调用 getBean()时，相当于执行 new
原型类型，它在我们创建容器的时候并没有实例化，而是当我们获取 bean 的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象
c. request：每次 HTTP 请求都会创建一个新的 Bean，该作用域仅适用于 WebApplicationContext 环境
d. session：同一个 HTTP Session 共享一个Bean，不同 Session 使用不同的 Bean，仅适用于 WebApplicationContext 环境
e. global-session：一般用于 Portlet 应用环境，该运用域仅适用于 WebApplicationContext 环境
5）factory-bean="beanId"：工厂模式，用来注入依赖关系
6）factory-method：工厂方法，属性值必须与 Java 中定义的方法名一致
如：实例工厂模式
<bean id="factory" class="com.ncdx.pojo.PeopleFactory"></bean>
<bean id="create" factory-bean="factory" factory-method="createPeople"></bean>
静态工厂模式：方法是静态的
<bean id="newPeo" class="com.ncdx.pojo.PeopleStaticFactory" factory-method="newInstance"></bean>
7）init-method：在 bean 的所有必需属性被容器初始化之后，调用回调方法。属性值必须与 Java 中定义的方法名一致
8）destroy-method：当包含该 bean 的容器被销毁时，使用回调方法。属性值必须与 Java 中定义的方法名一致
9）parent="beanId"：继承。Spring Bean 定义的继承与 Java 类的继承无关，但是继承的概念是一样的
4. 下图表达了 Bean 与 Spring 容器之间的关系：
5. DI
1. Spring 框架的核心功能之一就是通过依赖注入的方式来管理 Bean 之间的依赖关系
2. 当类 A 中需要依赖另一个类对象 B 时，将类 B 通过 IoC 注入到类 A 中的过程就叫依赖注入
3. DI 主要有两种：
1）基于构造函数的 DI
a. 当容器调用带有多个参数的构造函数的类时，实现基于构造函数的 DI
2）基于 setter 方法的 DI
b. 基于 setter 方法的 DI 是通过在调用无参数的构造函数或无参数的静态工厂方法实例化 bean 之后，容器调用 bean 的 setter 方法来实现的
4. 给 Bean 的属性赋值(注入)：
1）通过构造方法设置属性值
<constructor-arg index="0" type="" value=""/>
<constructor-arg ref="beanId"/>
如：
<bean id="exampleBean" class="examples.ExampleBean">
<constructor-arg type="int" value="2001"/>
<constructor-arg type="java.lang.String" value="Zara"/>
</bean>
<bean id="foo" class="x.y.Foo">
<constructor-arg ref="bar"/>
<constructor-arg ref="baz"/>
</bean>
<bean id="bar" class="x.y.Bar"/>
<bean id="baz" class="x.y.Baz"/>
2）如果属性类型是基本数据类型或 String 等简单类型或简单对象类型
<property name="" value=""/>
<property name="" ref=""/>
如：
<bean id="john" class="com.example.Person">
<property name="name" value="John"/>
<property name="friends" ref="mary"/>
</bean>
<bean id="mary" class="com.example.Person">
<property name="name" value="Mary"/>
</bean>
可写成：
<bean id="john" class="com.example.Person"
p:name="John"
p:friends-ref="mary"/>
</bean>
<bean id="mary" class="com.example.Person"
p:name="mary"/>
</bean>
还可写成：
<bean id="john" class="com.example.Person">
<property name="name">
<value>John</value>
</property>
<property name="friends">
<ref>mary</ref>
</property>
</bean>
<bean id="mary" class="com.example.Person">
<property name="name" value="Mary"/>
</bean>
3）注入内部 Bean，如：
<bean id="outerBean" class="...">
<property name="target">
<bean id="innerBean" class="..."/>
</property>
</bean>
4）如果属性类型是数组
<property name="">
<array>
<value>...</value>
<value>...</value>
....
</array>
</property>
5）如果属性类型是 Set<?>
<property name="">
<set>
<value>...</value>
<value>...</value>
<ref bean="beanId"/>
<ref bean="beanId"/>
....
</set>
</property>
6）如果属性类型是 List<?>
<property name="">
<list>
<value>...</value>
<value>...</value>
<ref bean="beanId"/>
<ref bean="beanId"/>
....
</list>
</property>
7）如果属性类型是 Map<?, ?>
<property name="">
<map>
<entry key="" value="" />
<entry key="" value="" />
<entry key="" value-ref="beanId"/>
<entry key="" value-ref="beanId"/>
....
</map>
</property>
8）如果属性类型是 Properties
<property name="">
<props>
<prop key="">...</prop>
<prop key="">...</prop>
....
</props>
</property>
6. Spring 自动装配
1. 在 Spring 配置文件中，Spring 容器可以使用自动装配进行依赖注入，即可以不配置符合自动装配条件的 <property name="" ref=""/>。
1）自动注入只会影响 ref，不会影响 value 赋值
2）自动装配可以显著减少需要指定的属性或构造器参数
2. 两种自动装配方法：
1）<bean/> 中的 autowire 属性，只对这个 <bean/> 生效
2）<beans/> 中的 default-autowire 属性，全局配置，即对该文件中所有 <bean/> 生效
3. 自动装配属性可取值：
1）default：默认值，取决于全局 default-autowire="" 的值。默认全局和局部都没有配置的情况下，相当于 no
2）no：不自动装配
3）byName：通过名称自动装配，即尝试将它的属性名与配置文件中定义为相同名称的 beans 进行匹配和连接
a. 如果找到匹配项，它将注入这些 beans，否则，它将抛出异常
b. 例如，在配置文件中，如果一个 bean 定义设置为自动装配 byName，并且它包含 factory 属性（即，它有一个 setFactory(...) 方法），那么 Spring 就会查找 id 为 "factory" 的 bean，并用它来设置这个属性。你仍然可以使用 <property/> 标签连接其余的属性
<bean id="builder" class="com.ncdx.Builder>
<property name="factory" ref="factory" />
<property name="name" value="Sun" />
</bean>
<bean id="factory" class="com.ncdx.Factory" />
简写为：
<bean id="builder" class="com.ncdx.Builder" autowire="byName">
<property name="name" value="Sun" />
</bean>
<bean id="factory" class="com.ncdx.Factory" />
4）byType：根据类型自动装配，即在 spring 容器中匹配 bean 的 class
a. 如果存在多个相同 class 的 bean，会抛出一个致命的异常：expected single matching bean but found 2
b. 例如，在配置文件中，如果一个 bean 定义设置为自动装配 byType，并且它包含 Student 类型的 student 属性，那么 Spring 就会查找 class 为 "com.ncdx.Student" 的 bean，并用它来设置这个属性。你仍然可以使用 <property/> 标签连接其余的属性
<bean id="teacher" class="com.ncdx.Teacher>
<property name="stu" ref="student" />
<property name="name" value="LiMing" />
</bean>
<bean id="student" class="com.ncdx.Student" />
简写为：
<bean id="teacher" class="com.ncdx.Teacher" autowire="byType">
<property name="name" value="LiMing" />
</bean>
<bean id="student" class="com.ncdx.Student" />
5）constructor：类似于 byType，适用于构造函数参数类型
a. 如果在容器中没有一个构造函数参数类型的 bean，会抛出一个致命错误
b. 例如，在配置文件中，如果一个 bean 定义设置为通过构造函数自动装配，而且它有一个带有 Student 类型的参数之一的构造函数，那么 Spring 就会查找 class 为 "com.ncdx.Student" 的 bean，并用它来设置构造函数的参数。你仍然可以使用 <constructor-arg/> 标签连接其余属性
<bean id="teacher" class="com.ncdx.Teacher>
<constructor-arg ref="student" />
<constructor-arg value="LiMing"/>
</bean>
<bean id="student" class="com.ncdx.Student" />
简写为：
<bean id="teacher" class="com.ncdx.Teacher" autowire="constructor">
<constructor-arg value="LiMing"/>
</bean>
<bean id="student" class="com.ncdx.Student" />
4. 自动装配的局限性:
1）不能自动装配简单类型包括基本类型，字符串等
2）自动装配不如显式装配精确
7. AOP
1. Spring 框架的一个关键组件是面向切面编程(AOP)，正常程序执行流程都是纵向执行流程，面向切面编程，就是在程序原有纵向执行流程中，针对某一个或某一些方法添加通知，形成横切面的过程
2. AOP 应用场景：日志记录、审计、声明式事务、安全性和缓存等
3. AOP 的优势：不需要修改原有程序代码，体现出程序高扩展性；原有功能相当于释放了部分逻辑，让职责更加明确
4. AOP 术语：
1）原有功能：切点（Pointcut）
2）通知（Advice），这是实际行动之前或之后执行的方法
a. before：前置通知
b. after：后置通知，是否出现异常都执行
c. after-returning：返回后置通知，只有当切点正确执行时执行
d. after-throwing：异常通知，在切点方法退出抛出异常时执行
e. around：环绕通知，在切点方法调用之前和之后执行
3）所有功能的总称叫做切面（Aspect），即切面具有一组提供横切需求的 APIs
4）把切面嵌入原有功能的过程叫做织入（Weaving），可以在编译时，类加载时和运行时完成
5）目标对象（Target object）：被一个或者多个方面（Aspect）所通知的对象，这个对象永远是一个被代理对象。也叫被通知对象
6）引用（Introduction）：允许你添加新方法或属性到现有的类中
5. Spring 提供了 3 种 AOP 实现方式
1）基于 XML Schema ：基于配置的 XML 来实现 AOP
a. 每个通知都需要实现接口或类
b. 在 <aop:config> 配置
2）基于 AspectJ
a. 每个通知不需要实现接口或类
b. 在 <aop:config> 的子标签 <aop:aspect> 中配置
3）基于 @AspectJ 注解
6. 使用 AOP 需要导入额外 Jar 包：spring-aop.jar、spring-aspects.jar、aopalliance.jar、aspectjweaver.jar
7. 基于 XML Schema 方式实现 AOP 步骤
1）新建通知类
a. 前置通知，实现 MethodBeforeAdvice 接口，重写方法 before(Method 切点方法对象, Object[] 切点方法参数, Object 切点方法所在类的引用)
b. 后置通知，实现 AfterReturningAdvice 接口，重写方法 afterReturning(Object 切点方法返回值, Method 切点方法对象, Object[] 切点方法参数, Object 切点方法所在类的引用)
c. 异常通知，实现 ThrowsAdvice 接口，必须自己写方法，且必须为 afterThrowing(),支持一个或四个参数，异常类型要和切点声明的异常类型一致
d. 环绕通知，实现 MethodInterceptor 接口，重写方法 invoke(MeehodInvocation invocation)
public class MyAspect implements MethodBeforeAdvice, AfterReturningAdvice, ThrowsAdvice, MethodInterceptor{
@Ovrride
public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable{
Logger logger = Logger.getLogger(MyAfter.class);
Users users = (Users) arg2[0];
if(arg0!=null){
logger.info(users.getUsername()+"登录成功!");
}else{
logger.info(users.getUsername()+"登录失败!"); } }
@Ovrride
public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
Users users = (Users) arg1[0];
Logger logger = Logger.getLogger(MyBefore.class);
logger.info(users.getUsername()+"在"+new Date().toLocaleString()+"正在进行登录"); } }
@Ovrride
public Object invoke(MeehodInvocation arg0)throws Throwable{
System.out.println("环绕-前置");
Object result = arg0.proceed(); //放行，调用切点方法
System.out.println("环绕-后置");
return result; }
}
2）在 Spring 配置文件中添加：
<!-- 声明切面 -->
<aop:config>
<!-- 声明切入点 -->
// 匹配任意一级包名，任意类名，任意方法名，任意方法参数
<aop:pointcut id="mypoint" expression="execution(* com.ncdx.*.service.impl.*.*(..))" />
<!-- 声明通知 -->
<aop:advisor advice-ref="mybefore" pointcut-ref="mypoint"/>
<aop:advisor advice-ref="myafter" pointcut-ref="mypoint"/>
<aop:advisor advice-ref="mythrow" pointcut-ref="mypoint"/>
<aop:advisor advice-ref="myarround" pointcut-ref="mypoint" />
</aop:config>
<!-- 定义目标对象（被通知对象或被代理对象） -->
<bean id="demo" class="com.ncdx.test.service.impl.Demo"></bean>
<!-- 定义通知类对象 -->
<bean id="mybefore" class="com.ncdx.advice.MyBefore"></bean>
<bean id="myafter" class="com.ncdx.advice.MyAfter"></bean>
<bean id="mythrow" class="com.ncdx.advice.MyThrow"></bean>
<bean id="myaround" class="com.ncdx.advice.MyAround"></bean>
8. 基于 AspectJ 方式实现 AOP 步骤
1）新建类
a. 不需要实现接口，方法名任意
b. 环绕通知
public class Logging {
public void beforeAdvice(){
System.out.println("");
}
public void afterAdvice(){
System.out.println("");
}
public void afterReturningAdvice(Object retVal){
System.out.println("Returning:" + retVal.toString() );
}
public void AfterThrowingAdvice(IllegalArgumentException ex){
System.out.println("There has been an exception: " + ex.toString());
}
public Object myAround(proceedingJoinPoint p){
System.out.println("环绕-前置");
Object result = p.proceed();//放行,调用切点方法
System.out.println("环绕-后置");
return result;
}
}
2）在 Spring 配置文件中添加：
<!--声明切面 -->
<aop:config>
<aop:aspect id="log" ref="logging">
<!-- 声明切入点 -->
<aop:pointcut id="mypoint" expression="execution(* com.ncdx.*.service.impl.*.*(..))" />
<!-- 声明通知方法 -->
<aop:before pointcut-ref="mypoint" method="beforeAdvice" />
<aop:after pointcut-ref="mypoint" method="afterAdvice" />
<aop:after-returning pointcut-ref="mypoint" method="afterReturningAdvice" returning="retVal" />
<aop:after-throwing pointcut-ref="mypoint" method="AfterThrowingAdvice" throwing="ex" />
<aop:around pointcut-ref="mypoint" method="myAround" />
</aop:aspect>
</aop:config>
<!-- 定义目标对象（被通知对象或被代理对象） -->
<bean id="demo" class="com.ncdx.test.service.impl.Demo"></bean>
<!-- 定义 Logging 方面 -->
<bean id="logging" class="com.ncdx.advice.Logging"></bean>
9. 基于 @AspectJ 注解方式实现 AOP 步骤
1）在 XML 配置文件中添加：<aop:aspectj-autoproxy />
a. 自动代理
b. 含有属性 proxy-target-class="boolean"：
默认值为 false：使用 JDK 动态代理，不需要额外导入 jar 包；
true：使用 cglib 动态代理，需要额外导入 cglib.jar 和 asm.jar
2）Spring 不会自动去寻找注解，必须告诉 Spring 哪些包下的类中可能有注解
<context:component-scan base-package="com.ncdx.advice" />
3）在切点所在的类上添加 @Component
a. 相当于 <bean id="" /> 的作用
b. 如果没有参数，把类名首字母变小写，作为 bean 的 id 值
4）声明切入点的方式有两种：
a. 某个范围内的方法会被执行，一般声明在 Aspect 类中的一个空方法上面：@Pointcut("execution(* com.ncdx.*.service.impl.*.*(..))")
b. 具体到哪个方法会真正被执行，声明在切点方法上面：@Pointcut("execution(* com.ncdx.service.impl.Student.getName())")
5）声明一个 Aspect 类，在切面类上添加 @Component 和 @Aspect
a. @Aspect ，相当于 <aop:aspect/>
b. 如：
@Component
@Aspect
public class AspectModule {
// 声明某个范围的方法会被执行
@Pointcut("execution(* com.ncdx.*.service.impl.*.*(..))")
public void selectAll(){}
6）声明通知
@Before("execution(* com.ncdx.*.service.impl.*.*(..)")
或
@Before("selectAll()")
或
@Before(pointcut="selectAll()")
public void doBeforeTask() {....}
@After("execution(* com.ncdx.service.impl.Student.getName())")
或
@After("getName()")
public void doAfterTask() {....}
@AfterReturning(pointcut = "selectAll()", returning="retVal")
public void doAfterReturnningTask(Object retVal) {....}
@AfterThrowing(pointcut = "selectAll()", throwing="ex")
public void doAfterThrowingTask(Exception ex) {....}
@Around("selectAll()")
public void doAroundTask() {....}
}
8. MyBatis 与 Spring 的整合
1. MyBatis 与 Spring 的整合步骤： 1）导入额外 jar 包：spring-jdbc.jar、mybatis.jar、mybatis-spring.jar、mysql-connector-java.jar 2）在 Spring 配置文件添加： <!-- 注解扫描 --> <context:component-scan base-package="com.ncdx.*"></context:component-scan> <!-- 加载属性文件，如果需要加载多个配置文件用逗号分割，在被 Spring 管理的类中通过 @Value{"${}"} 取出 xxx.properties 中的内容 --> <context:property-placeholder location="classpath:db.properties"></context:property-placeholder> <!-- 数据源 --> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="${mysqlDriver}"></property> <property name="url" value="${mysqlURL}"></property> <property name="username" value="${mysqlUser}"></property> <property name="password" value="${mysqlPwd}"></property> </bean> <!-- SqlSessionFactory创建 --> <bean id="factory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"></property> <property name="typeAliasesPackage" value="com.ncdx.pojo"></property> </bean> <!-- Mapper扫描器 --> <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <property name="basePackage" value="com.ncdx.mapper"></property> <property name="sqlSessionFactoryBeanName" value="factory"></property> </Spring boot：thymeleaf 没有正确渲染片段What's the difference between @Component, @Repository & @Service annotations in Spring?(代码片段
spring练习，在Eclipse搭建的Spring开发环境中，使用set注入方式，实现对象的依赖关系，通过ClassPathXmlApplicationContext实体类获取Bean对象(代码片段
Spring Rest 文档。片段生成时 UTF-8 中间字节无效 [重复]
解决spring-boot启动中碰到的问题：Cannot determine embedded database driver class for database type NONE(转)(代码片段