【Java學習】 Spring的基礎理解 IOC、AOP以及事務

//1.引入jar包

//2.編輯組態檔
<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
設定物件  id為唯一限定名 一般為類名的小寫   class是類所在的位置
    <bean id="teacher" class="com.qiang.pojo.Teacher"></bean>
</beans>

//3.測試
@Test
public void testTeacherCreate(){
    //載入組態檔
    ApplicationContext ac=new ClassPathXmlApplicationContext("applicationConfig.xml");
    Teacher teacher = ac.getBean("teacher", Teacher.class);
    System.out.println(teacher);
}

//在以上程式碼中  如果使用的是ApplicationContext 則在進行載入組態檔時 就已經在IOC容器中建立好了teacher物件
//如果是使用的是 BeanFactory ac 建立物件，則在getbean時才會建立物件（不可操作，因為該介面不對開發人員透明）

實體類物件
public class People implements Serializable {
    private String oid;
    public People() {
        System.out.println("第一步：執行無參構造");
    }
    public String getOid() {
        return oid;
    }
    public void setOid(String oid) {
        this.oid = oid;
        System.out.println("第二步： 呼叫set方法給屬性設定值......");
    }
    public void initMethod(){
        System.out.println("第三步：執行初始化方法............");
    }
    public void destroyMethod(){
        System.out.println("第五步：執行銷燬方法............");
    }
    @Override
    public String toString() {
        return "People{" +
                "oid='" + oid + '\'' +
                '}';
    }
}

組態檔  新增初始化方法 和銷燬方法
<bean id="people" class="com.qiang.pojo.People" 
    init-method="initMethod" 
    destroy-method="destroyMethod">
</bean>
其中的標籤init-method、destroy-method 中的方法是在實體類中自定義的

 測試類

/**
* 測試bean的生命週期
*/
@Test
public void testBeanLive(){
    //載入組態檔
    ClassPathXmlApplicationContext ac=new ClassPathXmlApplicationContext("applicationConfig2.xml");
    //獲取bean範例
    People people = ac.getBean("people", People.class);
    System.out.println("第四步：獲取bean範例物件 。。。");
    System.out.println(people);
    //手動銷燬
    ac.close();
}



結果：
第一步：執行無參構造
第三步：執行初始化方法............
第四步：獲取bean範例物件 。。。
People{oid='null'}
第五步：執行銷燬方法............

在實體類中 實現了BeanPostProcessor介面
    並重寫了
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    System.out.println("在初始化之前執行的方法");
    return bean;
}


@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    System.out.println("在初始化之後執行的方法");


    return bean;
}

實體類Dog
private String color;
private int age;


組態檔
<bean id="d1" class="com.qiang.pojo.Dog" autowire="byName">
    <property name="age" value="15"></property>
</bean>

測試類：
@Test
public void testDog1(){
    ApplicationContext ac=new ClassPathXmlApplicationContext("applicationConfig.xml");
    Dog d1 = ac.getBean("d1", Dog.class);
    System.out.println(d1.getAge());
}

結果：
15

組態檔
<bean id="d1" class="com.qiang.pojo.Dog" autowire="byType">
    <property name="age" value="21"></property>
</bean>


測試類：
@Test
public void testDog1(){
    ApplicationContext ac=new ClassPathXmlApplicationContext("applicationConfig.xml");
    Dog d1 = ac.getBean(Dog.class);
    System.out.println(d1.getAge());
}


結果：
21

分析：  由於註解@Autowired是預設按型別裝配的，一個型別的可能會有多個實現方法
        因此在演示的時候 就可以選擇一個介面，有多個實現類來作為演示

1.構建一個介面
public interface TeacherService {
    public void sayName();
    public void saysex();
}


2.建立多個實現類（以三個舉例）
@Component
public class TeacherServiceImpl1 implements TeacherService {
    @Override
    public void sayName() {
        System.out.println("A");
    }
}

@Component
public class TeacherServiceImpl1 implements TeacherService {
    @Override
    public void sayName() {
        System.out.println("B");
    }
}

@Component
public class TeacherServiceImpl1 implements TeacherService {
    @Override
    public void sayName() {
        System.out.println("C");
    }
}

3.建立兩外一個類，可以呼叫該類的實現類
public class TeacherController {
    @Autowired
    //建立物件
    private TeacherService teacherService;
    public void soutResult(){
        teacherService.sayName();
    }
}

4.修改組態檔 開啟掃描

<!--    測試註解開發-->
    <context:component-scan base-package="com.qiang"></context:component-scan>

5.測試：

@Test
public void testAopAno(){
    ApplicationContext ac=new ClassPathXmlApplicationContext("applicationConfig.xml");
    TeacherController contro = ac.getBean("teacherController", TeacherController.class);
    contro.soutResult();
}
6.觀察結果：
org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'teacherController': Unsatisfied dependency expressed through field 'teacherService'; nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.qiang.service.TeacherService' available: expected single matching bean but found 3: teacherServiceImpl1,teacherServiceImpl2,teacherServiceImpl3

分析：由於在service介面有多個實現類，使用autowired是按型別注入，可能會找不到使用哪個  因此可以搭配使用@Qualifier註解


修改第三步：
public class TeacherController {
    @Autowired
    @Qualifier("teacherServiceImpl1")
    //建立物件
    private TeacherService teacherService;
    public void soutResult(){
        teacherService.sayName();
    }
}
繼續進行測試  結果為：
A
結果顯示正常


繼續修改第三步：
public class TeacherController {
   @Resource(name = "teacherServiceImpl1")
    //建立物件
    private TeacherService teacherService;
    public void soutResult(){
        teacherService.sayName();
    }
}
繼續進行測試  結果為：
A
結果顯示正常

1.新增jar包

2.建造實體類和代理物件類
    普通類應包含一個普通方法，該普通方法也就是要增強的那個方法
public class Student implements Serializable {
    public void add(){
        System.out.println("這個只是一個普通的方法");
    }
}


public class StudentProxy {
    //設定前置通知
    public void before(){
        System.out.println("前置通知。。。。。");
    }
    //設定後置返回通知
    public void afterreturning(){
        System.out.println("後置返回通知....");
    }
    //設定最終通知
    public void after(){
        System.out.println("最終通知....");
    }
    //設定環繞通知
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("環繞通知前");
        proceedingJoinPoint.proceed();
        System.out.println("環繞通知後....");
    }
    //設定異常通知
    public void afterThrow(){
        System.out.println("異常通知....");
    }
}



3.修改組態檔


在修改組態檔時應注意，標頭檔案也需要進行修改

xmlns:aop="http://www.springframework.org/schema/aop"
xsi:http://www.springframework.org/schema/aop
    https://www.springframework.org/schema/aop/spring-aop.xsd"

//注入
<bean id="student" class="com.qiang.pojo.Student"></bean>
<bean id="studentProxy" class="com.qiang.pojo.StudentProxy"></bean>

<aop:config >
    <!--切入點-->
    <aop:pointcut id="pc" expression="execution(* com.qiang.pojo.Student.add(..))"/>
    <!--設定切面-->
    <aop:aspect ref="studentProxy">
        <!--將增強應用到具體的方法上-->
        <!--前置通知-->
        <aop:before method="before" pointcut-ref="pc"></aop:before>
        <!--後置返回通知-->
       <aop:after-returning method="afterreturning" pointcut-ref="pc"></aop:after-returning>
        <!--最終通知-->
        <aop:after method="after" pointcut-ref="pc"></aop:after>
        <!--環繞通知-->
        <aop:around method="around" pointcut-ref="pc"></aop:around>
    </aop:aspect>
以上沒有演示異常通知，異常通知在程式發生異常時才會發生。


測試：
@Test
public void testAopXmlDemo1(){
    ApplicationContext ac=new ClassPathXmlApplicationContext("applicationConfig.xml");
    Student student = ac.getBean("student", Student.class);
    student.add();
}



結果：

前置通知。。。。。
環繞通知前
這個只是一個普通的方法
環繞通知後....
最終通知....
後置返回通知....

只需要修改代理類物件就可以了
@Component
@Aspect //生成代理物件
public class UserProxy {




//    抽取切入點
    @Pointcut(value = "execution(* org.qiang.aop.anno.pojo.User.add(..))")
    public void pointcutDemo(){


    }
    //前置通知
    @Before(value = "pointcutDemo()")
    public void before(){
        System.out.println("前置通知。。。");
    }
   
   
    //後置返回通知
    @AfterReturning(value = "pointcutDemo()")
    public void afterReturning(){
        System.out.println("後置返回通知afterReturning....");
    }
   
   
    //環繞通知
    @Around(value = "pointcutDemo()")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("環繞之前....");
        // 被增強的方法執行了
        proceedingJoinPoint.proceed();
        System.out.println("環繞之後....");
    }
    
    
//    //異常通知 只有手動創造了異常才可以觸發這個通知
//    @AfterThrowing(value = "pointcutDemo()")
//    public void afterThrowing(){
//        System.out.println("異常通知 afterThrowing......");
//    }


    
    
    //最終通知
    @After(value = "pointcutDemo()")
    public void after(){
        System.out.println("最終通知....");
    }
    
}

public void testdemo1() throws SQLException {
    Connection conn= DriverManager.getConnection("","","");
    //關閉自動提交
    conn.setAutoCommit(false);
    try {
        PreparedStatement ptst=conn.prepareStatement("insert into bank  values=(?,?)");
        
        ptst.executeUpdate();
        
    }catch (Exception e){
    //再發生異常時，就會進行事務的回滾
        conn.rollback();
    }
    
}