Bean注解配置光速入門
-
步驟一: 創(chuàng)建 web 項目,引入 Spring 的開發(fā)包
在 Spring 的注解的 AOP 中需要引入 spring-aop 的 jar 包
-
步驟二: 引入相關(guān)配置文件
在applicationContext.xml中引入約束
引入約束:(引入 context 的約束):
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
</beans>
- 步驟三: 編寫相關(guān)的類
public interface UserDao {
public void sayHello();
}
public class UserDaoImpl implements UserDao {
@Override
public void sayHello() {
System.out.println("Hello Spring...");
}
}
- 步驟四: 配置注解掃描
<!-- Spring 的注解開發(fā):組件掃描(類上注解: 可以直接使用屬性注入的注解) -->
<context:component-scan base-package="com.itheima.spring.demo1"/>
- 步驟五: 在相關(guān)的類上添加注解
@Component(value="userDao")
public class UserDaoImpl implements UserDao {
@Override
public void sayHello() {
System.out.println("Hello Spring Annotation...");
}
}
- 步驟六: 編寫測試類
@Test
public void demo2() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext( "applicationContext.xml");
UserDao userDao = (UserDao) applicationContext.getBean("userDao");
userDao.sayHello();
}
Spring中Bean管理常用的注解
- @Component注解 組件(作用在類上)
Spring 中提供@Component 的三個衍生注解:(功能目前來講是一致的)
@Controller:WEB層
@Service:業(yè)務(wù)層
@Repository:持久層
這三個注解是為了讓標(biāo)注類本身的用途清晰三娩，Spring后續(xù)會增強(qiáng)其功能
- 屬性注入的注解(使用注解注入的方式, 可以不用提供 set方法 相當(dāng)于反射)
@Value:用于注入普通類型.
@Autowired:自動裝配:
* 默認(rèn)按類型進(jìn)行裝配.
* 按名稱注入:
* @Qualifier:強(qiáng)制使用名稱注入.
@Resource 相當(dāng)于:
* @Autowired 和@Qualifier 一起使用.
- Bean的Scope注解
@Scope:
* singleton: 單例
* prototype:
- Bean的生命周期的注解
@PostConstruct :相當(dāng)于 init-method
@PreDestroy :相當(dāng)于 destroy-method
-
Spring的Bean管理方式對比
XML和注解:
* XML:結(jié)構(gòu)清晰.
* 注解:開發(fā)方便.(屬性注入.)
實(shí)際開發(fā)中還有一種 XML 和注解整合開發(fā):
* Bean由XML配置,但是使用的屬性使用注解注入
Spring AOP概念
- ** Spring的AOP的由來**
AOP 最早由AOP聯(lián)盟的組織提出的,制定了一套規(guī)范.Spring將AOP思想引入到框架中,必須遵守AOP 聯(lián)盟的規(guī)范.
- ** 底層實(shí)現(xiàn)**
代理機(jī)制:
Spring 的AOP的底層用到兩種代理機(jī)制：
* JDK 的動態(tài)代理:針對實(shí)現(xiàn)了接口的類產(chǎn)生代理.
* Cglib 的動態(tài)代理:針對沒有實(shí)現(xiàn)接口的類產(chǎn)生代理. 應(yīng)用的是底層的字節(jié)碼增強(qiáng)的技術(shù) 生成當(dāng)前類
的子類對象```
- ** 為什么學(xué)習(xí)AOP **
對程序進(jìn)行增強(qiáng):不修改源碼的情況下,AOP可以進(jìn)行權(quán)限校驗,日志記錄,性能監(jiān)控,事務(wù)控制.
Spring 底層AOP實(shí)現(xiàn)原理(了解)
- JDK 動態(tài)代理增強(qiáng)一個類中方法
public class MyJDKProxy implements InvocationHandler {
private UserDao userDao;
public MyJDKProxy(UserDao userDao) {
this.userDao = userDao;
}
// 編寫工具方法：生成代理：
public UserDao createProxy(){
UserDao userDaoProxy = (UserDao)
Proxy.newProxyInstance(userDao.getClass().getClassLoader(),
userDao.getClass().getInterfaces(), this);
return userDaoProxy;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
if("save".equals(method.getName())){
System.out.println("權(quán)限校驗================");
}
return method.invoke(userDao, args);
}
}
- Cglib 動態(tài)代理增強(qiáng)一個類中的方法
public class MyCglibProxy implements MethodInterceptor{
private CustomerDao customerDao;
public MyCglibProxy(CustomerDao customerDao){
this.customerDao = customerDao;
}
// 生成代理的方法:
public CustomerDao createProxy(){
// 創(chuàng)建 Cglib 的核心類:
Enhancer enhancer = new Enhancer();
// 設(shè)置父類:
enhancer.setSuperclass(CustomerDao.class);
// 設(shè)置回調(diào):
enhancer.setCallback(this);
// 生成代理：
CustomerDao customerDaoProxy = (CustomerDao) enhancer.create();
return customerDaoProxy;
}
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
if("delete".equals(method.getName())){
Object obj = methodProxy.invokeSuper(proxy, args);
System.out.println("日志記錄================");
return obj;
}
return methodProxy.invokeSuper(proxy, args);
}
}
Spring 基于AspectJ的AOP開發(fā)
- AOP開發(fā)中的相關(guān)術(shù)語
Joinpoint(連接點(diǎn)):所謂連接點(diǎn)是指那些被攔截到的點(diǎn)于购。在spring中,這些點(diǎn)指的是方法,因為 spring 只支持方法類型的連接點(diǎn).
Pointcut(切入點(diǎn)):所謂切入點(diǎn)是指我們要對哪些 Joinpoint 進(jìn)行攔截的定義.
Advice(通知/增強(qiáng)):所謂通知是指攔截到 Joinpoint 之后所要做的事情就是通知.通知分為前置通知,后置通知,異常通知,最終通知,環(huán)繞通知(切面要完成的功能)
Introduction(引介):引介是一種特殊的通知在不修改類代碼的前提下, Introduction 可以在運(yùn)行期為類動態(tài)地添加一些方法或Field.
Target(目標(biāo)對象):代理的目標(biāo)對象
Weaving(織入):是指把增強(qiáng)應(yīng)用到目標(biāo)對象來創(chuàng)建新的代理對象的過程.spring采用動態(tài)代理織入，而AspectJ 采用編譯期織入和類裝在期織入
Proxy（代理）:一個類被 AOP 織入增強(qiáng)后篓叶，就產(chǎn)生一個結(jié)果代理類
Aspect(切面): 是切入點(diǎn)和通知（引介）的結(jié)合
-
Spring 使用 XML方式進(jìn)行AOP開發(fā)
-
**步驟一: 引入相應(yīng)的jar包 **
- 步驟二: 引入 Spring 的配置文件
-
引入 AOP 約束:
<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" 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">
</beans>
- 步驟三: 編寫目標(biāo)類
創(chuàng)建接口和類:
public interface OrderDao {
public void save();
public void update();
public void delete();
public void find();
}
public class OrderDaoImpl implements OrderDao {
@Override
public void save() {
System.out.println("保存訂單...");
}
@Override
public void update() {
System.out.println("修改訂單...");
}
@Override
public void delete() {
System.out.println("刪除訂單...");
}
@Override
public void find() {
System.out.println("查詢訂單...");
}
}
目標(biāo)類的配置
<!-- 目標(biāo)類================ -->
<bean id="orderDao" class="cn.itcast.spring.demo3.OrderDaoImpl">
</bean>
- 步驟四: 整合Junit單元測試
引入 spring-test.jar
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo3 {
@Resource(name="orderDao")
private OrderDao orderDao;
@Test
public void demo1(){
orderDao.save();
orderDao.update();
orderDao.delete();
orderDao.find();
}
}
- 步驟五: 編寫切面類
public class MyAspectXml {
// 前置增強(qiáng)
public void before(){
System.out.println("前置增強(qiáng)===========");
}
}
- 步驟六: 配置增強(qiáng)
<!-- 配置切面類 -->
<bean id="myAspectXml" class="cn.itcast.spring.demo3.MyAspectXml"></bean>
<!-- 進(jìn)行 aop 的配置 -->
<aop:config>
<!-- 配置切入點(diǎn)表達(dá)式:哪些類的哪些方法需要進(jìn)行增強(qiáng) -->
<aop:pointcut expression="execution(*cn.itcast.spring.demo3.OrderDao.save(..))" id="pointcut1"/>
<!-- 配置切面 -->
<aop:aspect ref="myAspectXml">
<aop:before method="before" pointcut-ref="pointcut1"/>
</aop:aspect>
</aop:config>
<!-- 配置切面類 -->
<bean id="myAspectXml" class="cn.itcast.spring.demo3.MyAspectXml"></bean>
<!-- 進(jìn)行 aop 的配置 -->
<aop:config>
<!-- 配置切入點(diǎn)表達(dá)式:哪些類的哪些方法需要進(jìn)行增強(qiáng) -->
<aop:pointcut expression="execution(*cn.itcast.spring.demo3.*Dao.save(..))" id="pointcut1"/>
<aop:pointcut expression="execution(*cn.itcast.spring.demo3.*Dao.delete(..))" id="pointcut2"/>
<aop:pointcut expression="execution(*cn.itcast.spring.demo3.*Dao.update(..))" id="pointcut3"/>
<aop:pointcut expression="execution(*cn.itcast.spring.demo3.*Dao.find(..))" id="pointcut4"/>
<!-- 配置切面 -->
<aop:aspect ref="myAspectXml">
<aop:before method="before" pointcut-ref="pointcut1"/>
<aop:after-returning method="afterReturing"
pointcut-ref="pointcut2"/>
<aop:around method="around" pointcut-ref="pointcut3"/>
<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4"/>
<aop:after method="after" pointcut-ref="pointcut4"/>
</aop:aspect>
</aop:config>
- 切入點(diǎn)表達(dá)式
execution(表達(dá)式)
表達(dá)式:
[方法訪問修飾符] 方法返回值 包名.類名.方法名(方法的參數(shù))
public * cn.itcast.spring.dao.*.*(..)
* cn.itcast.spring.dao.*.*(..)
* cn.itcast.spring.dao.UserDao+.*(..)
* cn.itcast.spring.dao..*.*(..)
