Bean注解配置光速入門

• 步驟一: 創建 web 項目,引入 Spring 的開發包
  在 Spring 的注解的 AOP 中需要引入 spring-aop 的 jar 包
  
  
  
• 步驟二: 引入相關配置文件
  在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>

• 步驟三: 編寫相關的類

public interface UserDao {
    public void sayHello();
}
public class UserDaoImpl implements UserDao {
    @Override
    public void sayHello() {
      System.out.println("Hello Spring...");
    }
}

• 步驟四: 配置注解掃描

<!-- Spring 的注解開發:組件掃描(類上注解: 可以直接使用屬性注入的注解) -->
<context:component-scan base-package="com.itheima.spring.demo1"/>

• 步驟五: 在相關的類上添加注解

@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:業務層
@Repository:持久層
這三個注解是為了讓標注類本身的用途清晰，Spring后續會增強其功能

• 屬性注入的注解(使用注解注入的方式, 可以不用提供 set方法 相當于反射)

@Value:用于注入普通類型.
@Autowired:自動裝配:
 *  默認按類型進行裝配.
  *  按名稱注入:
  *  @Qualifier:強制使用名稱注入.
@Resource  相當于:
  * @Autowired 和@Qualifier 一起使用.

• Bean的Scope注解

@Scope:
    * singleton: 單例
    * prototype:

• Bean的生命周期的注解

@PostConstruct :相當于 init-method
@PreDestroy :相當于 destroy-method

• Spring的Bean管理方式對比
  

XML和注解:
    * XML:結構清晰.
    * 注解:開發方便.(屬性注入.)
實際開發中還有一種 XML 和注解整合開發:
    * Bean由XML配置,但是使用的屬性使用注解注入

Spring AOP概念

• ** Spring的AOP的由來**

AOP 最早由AOP聯盟的組織提出的,制定了一套規范.Spring將AOP思想引入到框架中,必須遵守AOP 聯盟的規范.

• ** 底層實現**

代理機制:
Spring 的AOP的底層用到兩種代理機制：
* JDK 的動態代理:針對實現了接口的類產生代理.
* Cglib 的動態代理:針對沒有實現接口的類產生代理. 應用的是底層的字節碼增強的技術 生成當前類
的子類對象```

• ** 為什么學習AOP **

對程序進行增強:不修改源碼的情況下,AOP可以進行權限校驗,日志記錄,性能監控,事務控制.

Spring 底層AOP實現原理(了解)

• JDK 動態代理增強一個類中方法

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("權限校驗================");
      }
      return method.invoke(userDao, args);
    }
}

• Cglib 動態代理增強一個類中的方法

public class MyCglibProxy implements MethodInterceptor{
    private CustomerDao customerDao;
    public MyCglibProxy(CustomerDao customerDao){
      this.customerDao = customerDao;
    }
    // 生成代理的方法:
    public CustomerDao createProxy(){
      // 創建 Cglib 的核心類:
      Enhancer enhancer = new Enhancer();
      // 設置父類:
      enhancer.setSuperclass(CustomerDao.class);
      // 設置回調:
      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開發

• AOP開發中的相關術語

Joinpoint(連接點):所謂連接點是指那些被攔截到的點。在spring中,這些點指的是方法,因為 spring 只支持方法類型的連接點.
Pointcut(切入點):所謂切入點是指我們要對哪些 Joinpoint 進行攔截的定義.
Advice(通知/增強):所謂通知是指攔截到 Joinpoint 之后所要做的事情就是通知.通知分為前置通知,后置通知,異常通知,最終通知,環繞通知(切面要完成的功能)
Introduction(引介):引介是一種特殊的通知在不修改類代碼的前提下, Introduction 可以在運行期為類動態地添加一些方法或Field.
Target(目標對象):代理的目標對象
Weaving(織入):是指把增強應用到目標對象來創建新的代理對象的過程.spring采用動態代理織入，而AspectJ 采用編譯期織入和類裝在期織入
Proxy（代理）:一個類被 AOP 織入增強后，就產生一個結果代理類
Aspect(切面): 是切入點和通知（引介）的結合

• Spring 使用 XML方式進行AOP開發

  • **步驟一: 引入相應的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>

• 步驟三: 編寫目標類

創建接口和類:
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("查詢訂單...");
      }
}

目標類的配置
<!-- 目標類================ -->
<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 {
      // 前置增強
      public void before(){
          System.out.println("前置增強===========");
      }
}

• 步驟六: 配置增強

<!-- 配置切面類 -->
<bean id="myAspectXml" class="cn.itcast.spring.demo3.MyAspectXml"></bean>
<!-- 進行 aop 的配置 -->
<aop:config>
      <!-- 配置切入點表達式:哪些類的哪些方法需要進行增強 -->
      <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>
<!-- 進行 aop 的配置 -->
<aop:config>
      <!-- 配置切入點表達式:哪些類的哪些方法需要進行增強 -->
      <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>

• 切入點表達式

execution(表達式)
表達式:
[方法訪問修飾符] 方法返回值 包名.類名.方法名(方法的參數)
public * cn.itcast.spring.dao.*.*(..)
           * cn.itcast.spring.dao.*.*(..)
           * cn.itcast.spring.dao.UserDao+.*(..)
           * cn.itcast.spring.dao..*.*(..)