//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(); } }