<dependencies>    <dependency>        <groupId>org.springframework</groupId>        <artifactId>spring-core</artifactId>        <version>5.3.8</version>    </dependency>    <dependency>        <groupId>org.springframework</groupId>        <artifactId>spring-beans</artifactId>        <version>5.3.8</version>    </dependency>    <dependency>        <groupId>org.springframework</groupId>        <artifactId>spring-context</artifactId>        <version>5.3.8</version>    </dependency>    <dependency>        <groupId>org.springframework</groupId>        <artifactId>spring-expression</artifactId>        <version>5.3.8</version>    </dependency>    <dependency>        <groupId>commons-logging</groupId>        <artifactId>commons-logging</artifactId>        <version>1.1.3</version>    </dependency>    <dependency> <!-- 引入 Junit 单元测试 -->        <groupId>junit</groupId>        <artifactId>junit</artifactId>        <version>4.7</version>        <scope>compile</scope>    </dependency></dependencies>

public class Monster {    private Integer id;    private String name;    // getter && setter && 有参构造 && 无参构造 && toString 方法}

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">    <bean id="monster01" class="com.heihu577.beans.Monster"> <!-- 配置好 id 以及 class -->        <property name="id" value="1"/> <!-- property 标签默认调用对象的 setter 方法进行创建 -->        <property name="name">            <value>张三</value> <!-- 当然, 也可以通过 value 标签配置字符串 -->        </property>    </bean></beans>

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void testBasicBean() {        Monster monster01 = ioc.getBean("monster01", Monster.class);        System.out.println(monster01);        /*            运行结果: Monster{id=1, name='张三'} -> hashCode = 767010715        */    }}

<bean id="monster03" class="com.heihu577.beans.Monster" p:name="张三" p:id="222"/>

<!-- 使用 setter 方法传递属性 --><bean id="monster01" class="com.heihu577.beans.Monster">    <property name="id" value="1"/>    <property name="name">        <value>张三</value>    </property></bean><!-- 使用 p 进行属性赋值 --><bean id="monster03" class="com.heihu577.beans.Monster" p:name="张三" p:id="222"/><!-- 使用构造方法方法传递属性 --><bean id="monster02" class="com.heihu577.beans.Monster">    <constructor-arg index="0" value="2"/>    <constructor-arg index="1" value="李四"/></bean>

public class Son {    private String name;    // getter && setter && 有参构造 && 无参构造 && toString 方法}public class Father {    private Son son;    private String name;    // getter && setter && 有参构造 && 无参构造 && toString 方法}

<bean id="son01" class="com.heihu577.beans.Son">    <property name="name" value="儿子"/></bean><bean id="father01" class="com.heihu577.beans.Father">    <property name="name" value="爸爸"/>    <property name="son" ref="son01"/> <!-- 使用 ref 进行依赖关系 --></bean>

<bean id="father01" class="com.heihu577.beans.Father">    <property name="name" value="爸爸"/>    <property name="son">        <bean class="com.heihu577.beans.Son">            <property name="name" value="儿子"/>        </bean>    </property></bean>

public class Obey {    private String name;}

public class Master {    private String name;    private Map<String, Obey> maps;    private Set<Obey> sets;    private List<Obey> lists;    private Obey[] obeys;    private Properties props;    // 有参构造 && 无参构造 && getter && setter && toString}

<bean id="obey01" class="com.heihu577.beans.Obey"/> <!-- 准备一个 JavaBean --><bean id="master01" class="com.heihu577.beans.Master">    <property name="name">        <value>字符串用value</value>    </property>    <property name="lists">        <list> <!-- List 类型用 list 标签 -->            <ref bean="obey01"/> <!-- lists.get(0) -->            <bean class="com.heihu577.beans.Obey"/> <!-- lists.get(1) -->        </list>    </property>    <property name="obeys">        <array> <!-- 数组类型用 array 标签 -->            <ref bean="obey01"/> <!-- obeys[0] -->            <bean class="com.heihu577.beans.Obey"/> <!-- obeys[1] -->        </array>    </property>    <property name="sets">        <set> <!-- set 类型 用 set 标签 -->            <ref bean="obey01"/>            <bean class="com.heihu577.beans.Obey"/>        </set>    </property>    <property name="maps">        <map> <!-- Map 类型用 map 标签 -->            <entry> <!-- map 类型包含 n 个 entry -->                <key><value>key01</value></key> <!-- entry 中的 key 指明了是 string 类型, 所以用 value 标签 -->                <ref bean="obey01"/> <!-- map 中的 value 部分 -->            </entry>        </map>    </property>    <property name="props">        <props> <!-- Properties 类型用 props 标签 -->            <prop key="username">root</prop>            <prop key="password">password</prop>        </props>    </property></bean>

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void testBasicBean() {        Master bean = ioc.getBean(Master.class);        System.out.println(bean);        /*            Master{name='字符串用value', maps={key01=com.heihu577.beans.Obey@1a3869f4}, sets=[com.heihu577.beans.Obey@1a3869f4, com.heihu577.beans.Obey@a38d7a3], lists=[com.heihu577.beans.Obey@1a3869f4, com.heihu577.beans.Obey@396e2f39], obeys=[com.heihu577.beans.Obey@1a3869f4, com.heihu577.beans.Obey@a74868d], props={password=password, username=root}}        */    }}

<utils:list id="myList">    <ref bean="obey01"/> <!-- lists.get(0) -->    <bean class="com.heihu577.beans.Obey"/> <!-- lists.get(1) --></utils:list><utils:set id="mySet">    <ref bean="obey01"/> <!-- lists.get(0) -->    <bean class="com.heihu577.beans.Obey"/> <!-- lists.get(1) --></utils:set><utils:map id="myMap">    <entry> <!-- map 类型包含 n 个 entry -->        <key><value>key01</value></key> <!-- entry 中的 key 指明了是 string 类型, 所以用 value 标签 -->        <ref bean="obey01"/> <!-- map 中的 value 部分 -->    </entry></utils:map><utils:properties id="myProperties">    <prop key="username">root</prop>    <prop key="password">password</prop></utils:properties><bean id="obey01" class="com.heihu577.beans.Obey"/> <!-- 准备一个 JavaBean --><bean id="master01" class="com.heihu577.beans.Master">    <property name="name">        <value>字符串用value</value>    </property>    <property name="lists" ref="myList"/>    <property name="obeys" ref="myList"/>    <property name="sets" ref="mySet"/>    <property name="maps" ref="myMap"/>    <property name="props" ref="myProperties"/></bean>

public class MyStaticFactory {    private static final Map<String, Monster> monsterMap = new ConcurrentHashMap<>();    static { // 放入所对应的数据        monsterMap.put("monster01", new Monster(1, "monster01"));        monsterMap.put("monster02", new Monster(1, "monster02"));    }    public static Monster getMonster(String key) { // 提供工厂方法        return monsterMap.get(key);    }}

<bean id="monster01" class="com.heihu577.factory.MyStaticFactory" factory-method="getMonster">    <!-- factory-method="静态方法名" -->    <constructor-arg index="0" value="monster01"/> <!-- 此时则作为静态方法的参数, 传入 monster01 的 key --></bean>

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void testBasicBean() {        Monster monster01 = ioc.getBean("monster01", Monster.class);        System.out.println(monster01);        /*            Monster{id=1, name='monster01'} -> hashCode = 511473681        */    }}

public class MyFactory {    private final Map<String, Monster> monsterMap = new ConcurrentHashMap<>();    {        monsterMap.put("monster01", new Monster(1, "monster01"));        monsterMap.put("monster02", new Monster(1, "monster02"));    }    public Monster getMonster(String key) {        return monsterMap.get(key);    }}

<bean id="myFactory" class="com.heihu577.factory.MyFactory"/><bean id="monster02" factory-bean="myFactory" factory-method="getMonster">    <constructor-arg index="0" value="monster02"/></bean>

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void testBasicBean() {        Monster monster02 = ioc.getBean("monster02", Monster.class);        System.out.println(monster02);        /*            Monster{id=1, name='monster02'} -> hashCode = 171497379        */    }}

public class MyFactoryBean implements FactoryBean<Monster> {    private final Map<String, Monster> monsterMap = new ConcurrentHashMap<>();    private String key;    public MyFactoryBean() {        monsterMap.put("monster01", new Monster(1, "monster01"));        monsterMap.put("monster02", new Monster(1, "monster02"));    }    public void setKey(String key) { // 提供 key 的 setter        this.key = key;    }    @Override    public Monster getObject() throws Exception {        return monsterMap.get(this.key); // 在这里返回具体的对象    }    @Override    public Class<?> getObjectType() {        return Monster.class; // 与指定的泛型一致    }    @Override    public boolean isSingleton() {        return FactoryBean.super.isSingleton();    }}

<bean id="monster01" class="com.heihu577.factory.MyFactoryBean">    <!-- 当spring读取到MyFactoryBean实现了FactoryBean时,则会走工厂方案,在这里我们只需要使用property配置属性即可 -->    <property name="key" value="monster01"/></bean>

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void testBasicBean() {        Monster monster01 = ioc.getBean("monster01", Monster.class);        System.out.println(monster01);        // Monster{id=1, name='monster01'} -> hashCode = 640363654    }}

<bean id="monster01" class="com.heihu577.beans.Monster">    <property name="id" value="1"/>    <property name="name" value="monster01"/></bean><bean id="monster02" parent="monster01"/>

<bean id="monster01" scope="prototype" class="com.heihu577.beans.Monster">    <property name="id" value="1"/>    <property name="name" value="monster01"/></bean>

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void testBasicBean() {        System.out.println(ioc.getBean("monster01", Monster.class));        System.out.println(ioc.getBean("monster01", Monster.class));        /*            运行结果:            Monster{id=1, name='monster01'} -> hashCode = 1177377518            Monster{id=1, name='monster01'} -> hashCode = 1773206895            可以发现两次的 hashCode 并不一样.        */    }}

public class Monster {    private Integer id;    private String name;    public void init() {        System.out.println("Monster init...");    }    public void destroy() {        System.out.println("Monster destroy...");    }    // ... 其他方法}

<bean id="monster01" class="com.heihu577.beans.Monster" init-method="init" destroy-method="destroy">    <property name="id" value="1"/>    <property name="name" value="张三"/></bean>

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void testBasicBean() throws Exception {        System.out.println(ioc.getBean("monster01", Monster.class));        System.out.println(ioc.getBean("monster01", Monster.class));        ((AbstractApplicationContext) ioc).close();        /*            运行结果:                Monster init...                Monster{id=1, name='张三'} -> hashCode = 926370398                Monster{id=1, name='张三'} -> hashCode = 926370398                Monster destroy...        */    }}

public class MyBeanPostProcessor implements BeanPostProcessor {    public Object postProcessBeforeInitialization(Object bean, String beanName) {        if (bean instanceof Monster) {            System.out.println("Monster -> " + beanName + " postProcessBeforeInitialization");        }        return bean;    }    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {        if (bean instanceof Monster) {            System.out.println("Monster -> " + beanName + " postProcessAfterInitialization");        }        return bean;    }}

<bean id="monster01" class="com.heihu577.beans.Monster" init-method="init" destroy-method="destroy">    <property name="id" value="1"/>    <property name="name" value="monster01"/></bean><bean id="myBeanPostProcessor" class="com.heihu577.beans.MyBeanPostProcessor"/>

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void testBasicBean() throws Exception {        System.out.println(ioc.getBean("monster01", Monster.class));        ((AbstractApplicationContext) ioc).close();        /*        运行结果:            Monster -> monster01 postProcessBeforeInitialization            Monster init...            Monster -> monster01 postProcessAfterInitialization            Monster{id=1, name='monster01'} -> hashCode = 422392391            Monster destroy...        */    }}

<context:property-placeholder location="classpath:settings.properties"/><!--文件内容:    id=1    name=zhangsan-->

<context:property-placeholder location="classpath:settings.properties"/><bean id="monster01" class="com.heihu577.beans.Monster">    <property name="id" value="${id}"/>    <property name="name" value="${name}"/></bean>

public class UserController {    private UserService userService;    public void sayHello() {        System.out.println("UserController sayHello");        userService.sayHello();    }    // getter && setter && 有参构造 && 无参构造 && toString 方法    // 一定要提供 setter, 否则无法自动装配}public class UserService {    private UserDAO userDAO;    public void sayHello() {        System.out.println("UserService sayHello");        userDAO.sayHello();    }    // getter && setter && 有参构造 && 无参构造 && toString 方法    // 一定要提供 setter, 否则无法自动装配}public class UserDAO {    public void sayHello() {        System.out.println("UserDAO sayHello");    }}

<bean id="userDAO" class="com.heihu577.beans.UserDAO"/><bean autowire="byName"  id="userService" class="com.heihu577.beans.UserService"/><bean autowire="byName"  id="userController" class="com.heihu577.beans.UserController"/>

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void testBasicBean() throws Exception {        UserController userController = ioc.getBean("userController", UserController.class);        userController.sayHello();        /*            UserController sayHello            UserService sayHello            UserDAO sayHello        */    }}

public class Person {    private Integer id; // 调用 returnId 成员方法得到值    private String name;  // 调用 returnString 静态方法得到值    private String hobby; // 使用 EL 进行表达式计算    private Integer age; // 使用 EL 进行表达式计算    public Person(Integer id, String name) {        this.id = id;        this.name = name;    }    public Person() {    }    public Integer returnId() {        return 1;    }    public static String returnString() {        return "张三";    }    public Integer getId() {        return id;    }    public void setId(Integer id) {        this.id = id;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getHobby() {        return hobby;    }    public void setHobby(String hobby) {        this.hobby = hobby;    }    public Integer getAge() {        return age;    }    public void setAge(Integer age) {        this.age = age;    }    @Override    public String toString() {        return "Person{" +                "id=" + id +                ", name='" + name + ''' +                ", hobby='" + hobby + ''' +                ", age=" + age +                '}';    }}

<bean id="person01" class="com.heihu577.beans.Person">    <property name="id" value="#{person01.returnId()}"/>    <property name="name" value="#{T(com.heihu577.beans.Person).returnString()}"/>    <property name="age" value="#{1+17}"/>    <property name="hobby" value="#{'打篮球'}"/></bean>

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void testBasicBean() throws Exception {        Person person01 = ioc.getBean("person01", Person.class);        System.out.println(person01);        /*            Person{id=1, name='张三', hobby='打篮球', age=18}        */    }}

// Controller 代码public class UserController {    private UserService userService;    public void sayHello() {        System.out.println("UserDAO sayHello...");        userService.sayHello();    }    public UserService getUserService() {        return userService;    }    public void setUserService(UserService userService) {        this.userService = userService;    }    @Override    public String toString() {        return "UserController{" +                "userService=" + userService +                '}';    }}// Service 代码public class UserService {    private UserDAO userDAO;    public void sayHello() {        System.out.println("UserService sayHello...");        userDAO.sayHello();    }    public UserDAO getUserDAO() {        return userDAO;    }    public void setUserDAO(UserDAO userDAO) {        this.userDAO = userDAO;    }    @Override    public String toString() {        return "UserService{" +                "userDAO=" + userDAO +                '}';    }}// DAO 代码public class UserDAO {    public void sayHello() {        System.out.println("UserDAO sayHello...");    }}

<context:component-scan base-package="com.heihu577.components">    <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/> <!-- 只扫描 Service 注解 -->    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/> <!-- 除了 Service 注解不扫描, 其他都扫描 -->    <!-- 如果想使用这两种模式, 必须在 component-scan 标签中增加该属性 use-default-filters="false" --></context:component-scan><!--     会扫描包即可, 当然 component-scan 还有其他参数, 但使用的方式并不多.-->

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void testBasicBean() throws Exception {        UserController userController = ioc.getBean("userController", UserController.class);        System.out.println(userController);        /*            UserController{userService=null}        */    }}

@Controllerpublic class UserController {    @Autowired    private UserService userService;    // 其他原有方法... }public class UserService {    @Autowired    private UserDAO userDAO;    // 其他原有方法... }@Repositorypublic class UserDAO {    // 其他原有方法... }

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void testBasicBean() throws Exception {        UserController userController = ioc.getBean("userController", UserController.class);        System.out.println(userController);        userController.sayHello();        /*        运行结果:            UserController{userService=UserService{userDAO=com.heihu577.components.UserDAO@6646153}}            UserDAO sayHello...            UserService sayHello...            UserDAO sayHello...        */    }}

<context:component-scan base-package="com.heihu577.components"/> <!-- 当前 IOC 容器已经扫描到了一个 UserService --><bean id="userService02" class="com.heihu577.components.UserService"/> <!-- 第二个 userService -->

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void testBasicBean() throws Exception {        BookService bookService = ioc.getBean("bookService", BookService.class);        System.out.println(bookService);        bookService.sayHello();        /*            com.heihu577.Service.BookService@5db45159            BookDAO sayHello...        */    }}

package com.heihu577.proxy01;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;public class VehicleProxyProvider {    private Vehicle target_vehicle;    public VehicleProxyProvider(Vehicle target_vehicle) {        this.target_vehicle = target_vehicle;    }    public Vehicle getProxy() {        ClassLoader classLoader = target_vehicle.getClass().getClassLoader();        Class<?>[] interfaces = target_vehicle.getClass().getInterfaces();        /*        *  public static Object newProxyInstance(ClassLoader loader, 指定类的 classLoader                                          Class<?>[] interfaces, 指定类实现的接口数组                                          InvocationHandler h) 使用匿名类进行实现该方法        * */        Vehicle o = (Vehicle) Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {            @Override            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                /* proxy -> 代理对象 method -> 方法名称 args -> 方法传递的参数 */                System.out.println("交通工具开始运行了...");                Object result = method.invoke(target_vehicle, args); // 方法的返回结果                System.out.println("交通工具运行完毕...");                return result; // 将方法返回            }        });        return o;    }}

@Testpublic void testProxy01() throws Exception {    Vehicle vehicle = new Car();    VehicleProxyProvider vehicleProxyProvider = new VehicleProxyProvider(vehicle); // 传递给代理对象    Vehicle proxy = vehicleProxyProvider.getProxy(); // 调用 getProxy Vehicle 类型的代理对象    proxy.run();    /*        交通工具开始运行了... (代理对象调用的)        Car Run方法正在调用... (Vehicle.run方法的实现)        交通工具运行完毕... (代理对象调用的)    */}

@Testpublic void testProxy01() throws Exception {    Vehicle vehicle = new Airplane(); // 首先准备一个真正的实例    Vehicle vehicleProxy = (Vehicle) Proxy.newProxyInstance(vehicle.getClass().getClassLoader(),            vehicle.getClass().getInterfaces(),            new InvocationHandler() {                @Override                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                    Object result = null; // 运行结果保存                    if (method.getName().equals("run")) { // 如果调用的方法名称为 run 方法的话                        System.out.println("进入到 Run 方法...");                        result = method.invoke(vehicle, args); // 真正的实例.run(args) 这样调用, 返回结果                        System.out.println("运行完毕 Run 方法...");                    }                    return result; // 返回方法运行完毕结果                }            });    vehicleProxy.run(); // 调用 run 方法}

@Testpublic void testProxy01() throws Exception {    Vehicle vehicle = new Airplane();    Vehicle vehicleProxy = (Vehicle) Proxy.newProxyInstance(vehicle.getClass().getClassLoader(),            vehicle.getClass().getInterfaces(),            new InvocationHandler() {                @Override                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                    Object result = null;                    System.out.println("前置通知");                    try {                        Object invoke = method.invoke(vehicle, args);                    } catch (Exception e) {                        e.printStackTrace();                        System.out.println("异常通知");                    } finally {                        System.out.println("最终通知");                    }                    System.out.println("后置通知");                    return result;                }            });}

public void before() { // 定义前置通知方法, 当然, 也可以定义参数, 从外部传递进来即可.    System.out.println("前置通知");}public void after() {    System.out.println("后置通知");}@Testpublic void testProxy01() throws Exception {    Vehicle vehicle = new Airplane();    Vehicle vehicleProxy = (Vehicle) Proxy.newProxyInstance(vehicle.getClass().getClassLoader(),            vehicle.getClass().getInterfaces(),            new InvocationHandler() {                @Override                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                    Object result = null;                    before(); // 调用前置方法                    try {                        Object invoke = method.invoke(vehicle, args);                    } catch (Exception e) {                        e.printStackTrace(); // 抛出异常                        System.out.println("异常通知");                    } finally {                        System.out.println("最终通知");                    }                    after(); // 调用后置方法                    return result;                }            });}

public class HeihuAOP {    public static void before() {        System.out.println("前置通知");    }    public static void after() {        System.out.println("后置通知");    }}

<dependency>    <groupId>org.aspectj</groupId>    <artifactId>aspectjweaver</artifactId>    <version>1.9.6</version></dependency><!-- AOP Alliance --><dependency>    <groupId>aopalliance</groupId>    <artifactId>aopalliance</artifactId>    <version>1.0</version></dependency><!-- CGLIB --><dependency>    <groupId>cglib</groupId>    <artifactId>cglib</artifactId>    <version>2.2</version></dependency><!-- Spring Aspects --><dependency>    <groupId>org.springframework</groupId>    <artifactId>spring-aspects</artifactId>    <version>5.3.8</version></dependency><!-- Spring AOP --><dependency>    <groupId>org.springframework</groupId>    <artifactId>spring-aop</artifactId>    <version>5.3.8</version></dependency>

<context:component-scan base-package="com.heihu577.aspectj"/><aop:aspectj-autoproxy/>  <!-- 当加入这行代码后, 被@Aspect注解类所指明的类|接口 ioc.getBean()返回的则是代理对象 (只能使用接口类型进行接收), 如果没有指明则是普通对象, 或者增加该属性 proxy-target-class="true" -->

public interface Vehicle {    public void run();    public String fly(String msg);}

@Component // 一定要加入扩展, 放入 IOC 容器中public class Airplane implements Vehicle {    @Override    public void run() {        System.out.println("Airplane Run方法正在调用...");    }    @Override    public String fly(String msg) {        String result = "Airplane fly方法正在调用..." + msg;        System.out.println(result);        return result;    }}

@Aspect@Componentpublic class VehicleAspectJ {    // execution(访问修饰符 方法返回类型 接口|类名.方法名(参数类型))    @Before("execution(public String com.heihu577.aspectj.Vehicle.fly(String))") // 不需要携带形式参数    public void before(JoinPoint joinPoint) {        Signature signature = joinPoint.getSignature(); // 获取方法签名, joinPoint 可以获取调用的参数等信息        System.out.println("前置通知 - 方法签名 -> " + signature.getName() + " 参数 -> " + Arrays.toString(joinPoint.getArgs()));    }    @After("execution(public String com.heihu577.aspectj.Vehicle.fly(String))")    public void after() { // 这里就不用静态方法了, 使用成员方法        System.out.println("后置通知");    }}

@Testpublic void testAspectJ() {    com.heihu577.aspectj.Vehicle airplane = ioc.getBean("airplane", com.heihu577.aspectj.Vehicle.class); // 这里接收一定要用接口类型, 因为返回来的是代理对象.    airplane.fly("哈哈哈");    /*        前置通知 - 方法签名 -> fly 参数 -> [哈哈哈]        Airplane fly方法正在调用...哈哈哈        后置通知    */}

@Before("execution(public String com.heihu577.aspectj.Vehicle.fly(String))") // 不需要携带形式参数

@After("execution(* *.*(..))") // 所有包的所有类全部执行 (这里的含义是 任意返回类型 任意类.任意方法(任意参数))

public void beforeMethod(JoinPoint joinPoint){    joinPoint.getSignature().getName(); // 获取目标方法名    joinPoint.getSignature().getDeclaringType().getSimpleName(); // 获取目标方法所属类的简单类名    joinPoint.getSignature().getDeclaringTypeName(); // 获取目标方法所属类的类名    joinPoint.getSignature().getModifiers(); // 获取目标方法声明类型(public、private、protected)    Object[] args = joinPoint.getArgs(); // 获取传入目标方法的参数，返回一个数组    joinPoint.getTarget(); // 获取被代理的对象, 比如说 ioc.getBean(Car.class) 返回的是 Car 的代理对象, 在这里可以得到 Car 对象自己    joinPoint.getThis(); // 获取代理对象自己, 得到代理对象}

public @interface AfterReturning {    String value() default "";    String pointcut() default "";    String returning() default ""; // 重点关注该注解属性    String argNames() default "";}

@Componentpublic class Hack {    public String getString() {        System.out.println("Hack getString...");        return "Hack String..."; // 返回结果    }}

@AfterReturning(value = "execution(String com.heihu577.components.Hack.getString())", returning = "res")public void hackGetString(JoinPoint joinPoint, Object res) { // 这里的 res 与 returning 指定的 res 相同    System.out.println("方法返回结果: res = " + res); // 在这里可以得到返回值}

@Testpublic void t2() {    Hack hack = ioc.getBean("hack", Hack.class);    hack.getString();    /*        Hack getString...        方法返回结果: res = Hack String...    */}

public @interface AfterThrowing {    String value() default "";    String pointcut() default "";    String throwing() default ""; // 重点关注该方法    String argNames() default "";}

@Componentpublic class Hack {    public Integer testThrowing() {        int i;        try {            i = 1 / 0;        } catch (Exception e) {            throw new RuntimeException("除0错误");        }        return i;    }}

@AfterThrowing(value = "execution(Integer com.heihu577.components.Hack.testThrowing())", throwing = "throwMsg")public void hackTestThrowing(JoinPoint joinPoint, RuntimeException throwMsg) {    System.out.println(throwMsg.getClass());    System.out.println(throwMsg.toString());}

@Testpublic void t3() {    Hack hack = ioc.getBean("hack", Hack.class);    hack.testThrowing();    /*        class java.lang.RuntimeException        java.lang.RuntimeException: 除0错误 // 输出信息        java.lang.RuntimeException: 除0错误 // 报错信息            at com.heihu577.components.Hack.testThrowing(Hack.java:21)            at com.heihu577.components.Hack$$FastClassBySpringCGLIB$$1e6e314.invoke(<generated>)    */}

@Componentpublic class Hack {    public String sayHi() {        return "Hi";    }}

@Around(value = "execution(String com.heihu577.components.Hack.sayHi())")public void AroundTest(ProceedingJoinPoint proceedingJoinPoint) {    try {        Object[] args = proceedingJoinPoint.getArgs();        System.out.println("前置通知, 执行参数: " + Arrays.asList(args));        Object result = proceedingJoinPoint.proceed(); // 执行该函数        System.out.println("返回通知, 函数运行结果 => " + result);    } catch (Throwable e) {        System.out.println("异常通知");        throw new RuntimeException(e);    } finally {        System.out.println("最终通知");    }}

@Testpublic void t4() {    Hack hack = (Hack) ioc.getBean("hack");    String data = hack.sayHi();    /*        前置通知, 执行参数: []        后置通知, 函数运行结果 => Hi        最终通知    */}

@Aspect@Componentpublic class AspectJUtils {    @Pointcut("execution(void com.heihu577.beans.Hack.sayHello())")    public void myPointCut() {}    @Before("myPointCut()")    public void beforeSayHello() {        System.out.println("SayHello1 Before...");    }    @After("myPointCut()")    public void afterSayHello() {        System.out.println("SayHello1 After...");    }}// 以及 AspectJUtils2@Aspect@Componentpublic class AspectJUtils2 {    @Pointcut("execution(void com.heihu577.beans.Hack.sayHello())")    public void myPointCut(){}    @Before("myPointCut()")    public void beforeSayHello() {        System.out.println("SayHello2 Before...");    }    @After("myPointCut()")    public void afterSayHello() {        System.out.println("SayHello2 After...");    }}

@Componentpublic class Hack {    public void sayHello() {        System.out.println("Hello World");    }}

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void before() {        Hack hack = ioc.getBean("hack", Hack.class);        hack.sayHello();        /*            SayHello1 Before...            SayHello2 Before...            Hello World            SayHello2 After...            SayHello1 After...        */    }}

@Order(2)@Aspect@Componentpublic class AspectJUtils {    @Pointcut("execution(void com.heihu577.beans.Hack.sayHello())")    public void myPointCut(){}    @Before("myPointCut()")    public void beforeSayHello() {        System.out.println("SayHello1 Before...");    }    @After("myPointCut()")    public void afterSayHello() {        System.out.println("SayHello1 After...");    }}// 以及 AspectJUtils2@Order(1)@Aspect@Componentpublic class AspectJUtils2 {    @Pointcut("execution(void com.heihu577.beans.Hack.sayHello())")    public void myPointCut(){}    @Before("myPointCut()")    public void beforeSayHello() {        System.out.println("SayHello2 Before...");    }    @After("myPointCut()")    public void afterSayHello() {        System.out.println("SayHello2 After...");    }}

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void before() {        Hack hack = ioc.getBean("hack", Hack.class);        hack.sayHello();        /*            SayHello2 Before...            SayHello1 Before...            Hello World            SayHello1 After...            SayHello2 After...        */    }}

package com.heihu577.xml;public interface UsbInterface {    public String start();}

package com.heihu577.xml;public class Phone implements UsbInterface {    @Override    public String start() {        System.out.println("Phone Starting...");        return "OK";    }}

public class AspectUtil {    public void beforeStart() {        System.out.println("AspectUtil beforeStart...");    }    public void afterStart() {        System.out.println("AspectUtil AfterStart...");    }    public void afterStartReturning(JoinPoint joinPoint, Object res) {        System.out.println("AspectUtil afterStartReturning...");        System.out.println(res);    }    public void afterStartThrowing(JoinPoint joinPoint, RuntimeException runtimeException) {        System.out.println("AspectUtil afterStartThrowing...");        System.out.println(runtimeException.toString());    }}

<bean id="phone" class="com.heihu577.xml.Phone"/> <!-- 配置普通的 bean 对象 --><bean id="aspectUtil" class="com.heihu577.xml.AspectUtil"/> <!-- 配置一个自认为的切面类 --><aop:config> <!-- 将自认为的切面类配置为真正的切面类 -->    <aop:pointcut id="myPointCut" expression="execution(String com.heihu577.xml.Phone.start())"/> <!-- 配置切面表达式 -->    <aop:aspect ref="aspectUtil"> <!-- 指定切面对象 -->        <aop:before method="beforeStart" pointcut-ref="myPointCut"/> <!-- 配置前置通知 -->        <aop:after method="afterStart" pointcut-ref="myPointCut"/> <!-- 配置后置通知 -->        <aop:after-returning method="afterStartReturning" pointcut-ref="myPointCut" returning="res"/> <!-- 配置最终通知 -->        <aop:after-throwing method="afterStartThrowing" pointcut-ref="myPointCut" throwing="runtimeException"/> <!-- 配置异常通知 --><!--            <aop:around method="" 配置环绕通知... -->    </aop:aspect></aop:config>

public class MyTester {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void before() {        UsbInterface phone = ioc.getBean("phone", UsbInterface.class);        phone.start();        /*            AspectUtil beforeStart...            Phone Starting...            AspectUtil AfterStart...            AspectUtil afterStartReturning...            OK        */    }}

<dependencies>    <dependency> <!-- 加入 Spring 开发的基本包 -->        <groupId>org.springframework</groupId>        <artifactId>spring-context</artifactId>        <version>5.3.8</version>    </dependency>    <dependency> <!-- 加入 Spring 开发切面编程需要的包 -->        <groupId>org.springframework</groupId>        <artifactId>spring-aspects</artifactId>        <version>5.3.8</version>    </dependency>    <dependency> <!-- 引入 Junit 单元测试 -->        <groupId>junit</groupId>        <artifactId>junit</artifactId>        <version>4.7</version>        <scope>compile</scope>    </dependency></dependencies>

<?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:context="http://www.springframework.org/schema/context"       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">    <context:component-scan base-package="com.heihu577.component"/> <!-- 扫描包 --></beans>

package com.heihu577.component;import org.springframework.stereotype.Component;@Component // 也可以使用 @Controller 注解public class UserAction {}

package com.heihu577.component;import org.springframework.stereotype.Component;@Component // 也可以使用 @Repository 注解public class UserDAO {    public void hi() {        System.out.println("UserDAO hi...");    }}

package com.heihu577.component;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Component;@Component // 也可以使用 @Service 注解public class UserService {    @Autowired // 也可以使用 @Resource    private UserDAO userDAO;    public void m1() {        userDAO.hi();    }}

public class T {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void t1() {        UserAction userAction = ioc.getBean("userAction", UserAction.class);        System.out.println(userAction); // com.heihu577.component.UserAction@358c99f5        UserService userService = ioc.getBean("userService", UserService.class);        System.out.println(userService); // com.heihu577.component.UserService@3ee0fea4        UserDAO userDAO = ioc.getBean("userDAO", UserDAO.class);        System.out.println(userDAO); // com.heihu577.component.UserDAO@48524010    }}

package com.heihu577.component;import org.springframework.context.annotation.Scope;import org.springframework.stereotype.Component;@Component // 也可以使用 @Controller 注解@Scope("prototype")public class UserAction {}

public class MyBeanPostProcessor implements BeanPostProcessor {    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {        System.out.println("MyBeanPostProcessor postProcessBeforeInitialization 被调用, beanName = " + beanName);        return bean;    }    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {        System.out.println("MyBeanPostProcessor postProcessAfterInitialization 被调用, beanName = " + beanName);        return bean;    }}

<context:component-scan base-package="com.heihu577.component"/><bean id="myBeanPostProcessor" class="com.heihu577.process.MyBeanPostProcessor"/>

@Component // 也可以使用 @Controller 注解@Scope("prototype")public class UserAction {    @PostConstruct // 相当于 init-method 属性    public void init() {        System.out.println("UserAction init...");    }}

public class T {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void t1() {        UserAction userAction = ioc.getBean("userAction", UserAction.class);        System.out.println(userAction);        UserService userService = ioc.getBean("userService", UserService.class);        System.out.println(userService);        UserDAO userDAO = ioc.getBean("userDAO", UserDAO.class);        System.out.println(userDAO);        /*            MyBeanPostProcessor postProcessBeforeInitialization 被调用, beanName = userDAO            MyBeanPostProcessor postProcessAfterInitialization 被调用, beanName = userDAO            MyBeanPostProcessor postProcessBeforeInitialization 被调用, beanName = userService            MyBeanPostProcessor postProcessAfterInitialization 被调用, beanName = userService            MyBeanPostProcessor postProcessBeforeInitialization 被调用, beanName = userAction            UserAction init... (这里使用 @PostConstruct 指定了 init-method 方法)            MyBeanPostProcessor postProcessAfterInitialization 被调用, beanName = userAction            com.heihu577.component.UserAction@2b6856dd            com.heihu577.component.UserService@5db45159            com.heihu577.component.UserDAO@6107227e        */    }}

package com.heihu577.aop;public interface UsbInterface {    public void start();}

package com.heihu577.aop;import org.springframework.stereotype.Component;@Componentpublic class Phone implements UsbInterface{    @Override    public void start() {        System.out.println("Phone Start...");    }}

@Aspect@Componentpublic class UsbAspect {    @Pointcut("execution(void com.heihu577.aop.UsbInterface.start())")    public void myPointCut() {    }    @Before("myPointCut()")    public void startBefore(JoinPoint joinPoint) {        System.out.println("start Before...");    }    @After("myPointCut()")    public void startAfter(JoinPoint joinPoint) {        System.out.println("start After...");    }    @AfterThrowing("myPointCut()")    public void afterThrowing() {        System.out.println("start After Throwing...");    }    @AfterReturning("myPointCut()")    public void afterReturning() {        System.out.println("start After Returning...");    }}

<context:component-scan base-package="com.heihu577"/> <!-- 扫描 --><aop:aspectj-autoproxy/> <!-- 开启 AOP -->

public class T {    private ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");    @Test    public void t1() {        UsbInterface bean = ioc.getBean(UsbInterface.class);        bean.start();        /*            MyBeanPostProcessor postProcessBeforeInitialization 被调用, beanName = phone            MyBeanPostProcessor postProcessAfterInitialization 被调用, beanName = phone            MyBeanPostProcessor postProcessBeforeInitialization 被调用, beanName = usbAspect            MyBeanPostProcessor postProcessAfterInitialization 被调用, beanName = usbAspect            MyBeanPostProcessor postProcessBeforeInitialization 被调用, beanName = userDAO            MyBeanPostProcessor postProcessAfterInitialization 被调用, beanName = userDAO            MyBeanPostProcessor postProcessBeforeInitialization 被调用, beanName = userService            MyBeanPostProcessor postProcessAfterInitialization 被调用, beanName = userService            start Before...            Phone Start...            start After Returning...            start After...        */    }}

package com.heihu577.process;import org.springframework.beans.BeansException;import org.springframework.beans.factory.config.BeanPostProcessor;import org.springframework.lang.Nullable;import org.springframework.stereotype.Component;@Componentpublic class MyBeanPostProcessor implements BeanPostProcessor {    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {        System.out.println("MyBeanPostProcessor postProcessBeforeInitialization 被调用, beanName = " + beanName + " " +                "class " + bean.getClass()); // 增加查看 class 的功能        return bean;    }    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {        System.out.println("MyBeanPostProcessor postProcessAfterInitialization 被调用, beanName = " + beanName + " class" +                " " + bean.getClass()); // 增加查看 class 的功能        return bean;    }}

MyBeanPostProcessor postProcessBeforeInitialization 被调用, beanName = phone class class com.heihu577.aop.Phone // 在进入 postProcessBeforeInitialization 之前还是 Phone 类型MyBeanPostProcessor postProcessAfterInitialization 被调用, beanName = phone class class com.sun.proxy.$Proxy18 // 在进入 postProcessAfterInitialization 之后变为了代理类型MyBeanPostProcessor postProcessBeforeInitialization 被调用, beanName = usbAspect class class com.heihu577.aop.UsbAspectMyBeanPostProcessor postProcessAfterInitialization 被调用, beanName = usbAspect class class com.heihu577.aop.UsbAspectMyBeanPostProcessor postProcessBeforeInitialization 被调用, beanName = userDAO class class com.heihu577.component.UserDAOMyBeanPostProcessor postProcessAfterInitialization 被调用, beanName = userDAO class class com.heihu577.component.UserDAOMyBeanPostProcessor postProcessBeforeInitialization 被调用, beanName = userService class class com.heihu577.component.UserServiceMyBeanPostProcessor postProcessAfterInitialization 被调用, beanName = userService class class com.heihu577.component.UserServicestart Before...Phone Start...start After Returning...start After...

@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)public @interface Component {    String value() default "";}

@Target(ElementType.TYPE) // 该注解可以修饰类中的哪部分类型@Retention(RetentionPolicy.RUNTIME) // 指定 ComponentScan 注解保留范围, 当前运行时生效public @interface ComponentScan {    String value() default ""; // 可以传入 value 属性, 默认值为空字符串}

@Componentpublic class MonsterDAO {}

@Component(value = "monsterService") // 将 MonsterService 注入到容器中public class MonsterService {}

public class NoBean {}

public class HeihuSpringApplicationContext {    private Class<?> springConfig;    public HeihuSpringApplicationContext(Class<?> springConfig) {        this.springConfig = springConfig;        initApplicationContext();    }    public void initApplicationContext() {        ComponentScan annotation = springConfig.getAnnotation(ComponentScan.class); // 得到该注解        String componentScanValue = annotation.value(); // 得到注解中的配置值        String classPath = componentScanValue.replace('.', '/'); // 得到真正的路径信息        System.out.println("要扫描的包: " + classPath);        URL classPathResource = springConfig.getClassLoader().getResource(classPath); // 得到 URL, 路径存在不返回 null        if (classPathResource != null) {            File file = new File(classPathResource.getPath()); // 得到 file 资源            if (file.isDirectory()) {                File[] files = file.listFiles(); // 得到所有编译好的文件信息                for (File f : files) { // 扫描 .class 的文件信息                    String fStr = f.toString(); // 字符串截取判断                    if (fStr.substring(fStr.indexOf(".")).equals(".class")) { // 判断最后是否是 .class 结尾                        String className = f.getName().replace(".class", "");                        String fullCLassPath = (classPath + "/" + className).replace("/", "."); // 再转换回来, 得到包名+类名                        try {                            Class<?> clazz = Class.forName(fullCLassPath);                            if (clazz.isAnnotationPresent(Component.class)) {                                System.out.println("是 Bean: " + clazz);                            } else {                                System.out.println("不是 Bean: " + clazz);                            }                        } catch (ClassNotFoundException e) {                            throw new RuntimeException(e);                        }                    }                }            }        } else {            System.out.println("扫描包出现了问题");        }    }}

@ComponentScan("com.heihu577.components")public class HeihuSpringConfig {}

public class T {    public static void main(String[] args) {        HeihuSpringApplicationContext heihuSpringApplicationContext = new HeihuSpringApplicationContext(HeihuSpringConfig.class);        /*            要扫描的包: com/heihu577/components            是 Bean: class com.heihu577.components.MonsterDAO            是 Bean: class com.heihu577.components.MonsterService            不是 Bean: class com.heihu577.components.SB        */    }}

@Target(ElementType.TYPE) // 该注解可以修饰类中的哪部分类型@Retention(RetentionPolicy.RUNTIME) // 指定 ComponentScan 注解保留范围, 当前运行时生效public @interface Scope {    String value() default "singleton"; // 默认单例}

package com.heihu577.ioc;public class BeanDefinition {    private String scope; // 当前 bean 作用范围    private Class<?> clazz; // 当前 bean 的 Class 对象    public BeanDefinition(String scope, Class<?> clazz) {        this.scope = scope;        this.clazz = clazz;    }    public BeanDefinition() {    }    public String getScope() {        return scope;    }    public void setScope(String scope) {        this.scope = scope;    }    public Class<?> getClazz() {        return clazz;    }    public void setClazz(Class<?> clazz) {        this.clazz = clazz;    }    @Override    public String toString() {        return "BeanDefinition{" +                "scope='" + scope + ''' +                ", clazz=" + clazz +                '}';    }}

private Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(); // 用于保存类原型

private Map<String, Object> singletonObject = new ConcurrentHashMap<>(); // 用于保存单例对象

public void initApplicationContext() {    ComponentScan annotation = springConfig.getAnnotation(ComponentScan.class); // 得到该注解    String componentScanValue = annotation.value(); // 得到注解中的配置值    String classPath = componentScanValue.replace('.', '/'); // 得到真正的路径信息    System.out.println("要扫描的包: " + classPath);    URL classPathResource = springConfig.getClassLoader().getResource(classPath); // 得到 URL, 路径存在不返回 null    if (classPathResource != null) {        File file = new File(classPathResource.getPath()); // 得到 file 资源        if (file.isDirectory()) {            File[] files = file.listFiles(); // 得到所有编译好的文件信息            for (File f : files) { // 扫描 .class 的文件信息                String fStr = f.toString(); // 字符串截取判断                if (fStr.substring(fStr.indexOf(".")).equals(".class")) { // 判断最后是否是 .class 结尾                    String className = f.getName().replace(".class", "");                    String fullCLassPath = (classPath + "/" + className).replace("/", "."); // 再转换回来, 得到包名+类名                    try {                        Class<?> clazz = Class.forName(fullCLassPath);                        if (clazz.isAnnotationPresent(Component.class)) {                            String beanName = clazz.getDeclaredAnnotation(Component.class).value();                            if (beanName.equals("")) { // 如果是没配置的情况, 那么定义为首字母小写                                beanName = className.substring(0, 1).toLowerCase() + className.substring(1);                            }                            BeanDefinition beanDefinition = new BeanDefinition();                            beanDefinition.setClazz(clazz); // 保存当前 class 类型                            if (clazz.isAnnotationPresent(Scope.class)) {                                // 前面有 Scope 注解定义                                String scopeValue = clazz.getAnnotation(Scope.class).value();                                beanDefinition.setScope(scopeValue);                            } else {                                beanDefinition.setScope("singleton"); // 默认 singleton                            }                            beanDefinitionMap.put(beanName, beanDefinition); // 保存容器                            System.out.println("是 Bean: " + clazz);                        } else {                            System.out.println("不是 Bean: " + clazz);                        }                    } catch (ClassNotFoundException e) {                        throw new RuntimeException(e);                    }                }            }        }    } else {        System.out.println("扫描包出现了问题");    }}

private Object createBean(BeanDefinition beanDefinition) {    Class<?> clazz = beanDefinition.getClazz();    try {        Object o = clazz.getDeclaredConstructor().newInstance();        return o;    } catch (InstantiationException e) {        throw new RuntimeException(e);    } catch (IllegalAccessException e) {        throw new RuntimeException(e);    } catch (InvocationTargetException e) {        throw new RuntimeException(e);    } catch (NoSuchMethodException e) {        throw new RuntimeException(e);    }}

public HeihuSpringApplicationContext(Class<?> springConfig) {    this.springConfig = springConfig;    initApplicationContext(); // 扫描包的代码    judgeBeanDefinition(); // 单例池初始化代码}public void judgeBeanDefinition() {    Set<Map.Entry<String, BeanDefinition>> entries = beanDefinitionMap.entrySet();    // 得到所有 entry    for (Map.Entry<String, BeanDefinition> entry : entries) { // 遍历 entry 信息        BeanDefinition beanDefinition = entry.getValue(); // 得到 beanDefinition 类        String scope = beanDefinition.getScope(); // 得到单例还是多例        if ("singleton".equalsIgnoreCase(scope)) { // 如果是单例            singletonObject.put(entry.getKey(), createBean(beanDefinition)); // 放入到单例容器中        }    }}

public Object getBean(String name) {    if (beanDefinitionMap.containsKey(name)) { // 如果 bean 存在        BeanDefinition beanDefinition = beanDefinitionMap.get(name); // 得到该 bean 的 class        String scope = beanDefinition.getScope(); // 拿到 单例|多例        if ("singleton".equalsIgnoreCase(scope)) { // 如果是 单例模式            return singletonObject.get(name); // 直接从单例容器中取        } else {            return createBean(beanDefinition); // 多例模式, 直接调用 createBean 进行创建        }    } else {        throw new NullPointerException("该 bean 不存在!");    }}

public class T {    public static void main(String[] args) {        HeihuSpringApplicationContext heihuSpringApplicationContext = new HeihuSpringApplicationContext(HeihuSpringConfig.class);        // monsterDAO 是单例, monsterService 是多例        Object bean1 = heihuSpringApplicationContext.getBean("monsterDAO");        Object bean2 = heihuSpringApplicationContext.getBean("monsterDAO");        System.out.println(bean1); // com.heihu577.components.MonsterDAO@5e481248        System.out.println(bean2); // com.heihu577.components.MonsterDAO@5e481248        Object bean3 = heihuSpringApplicationContext.getBean("monsterService");        Object bean4 = heihuSpringApplicationContext.getBean("monsterService");        System.out.println(bean3); // com.heihu577.components.MonsterService@66d3c617        System.out.println(bean4); // com.heihu577.components.MonsterService@63947c6b        Object bean = heihuSpringApplicationContext.getBean("ABC");        /*            Exception in thread "main" java.lang.NullPointerException: 该 bean 不存在!            at com.heihu577.ioc.HeihuSpringApplicationContext.getBean(HeihuSpringApplicationContext.java:110)            at T.main(T.java:17)        */    }}

private Object createBean(BeanDefinition beanDefinition) {    Class<?> clazz = beanDefinition.getClazz();    try {        Object o = clazz.getDeclaredConstructor().newInstance();        // ... 依赖注入核心代码        return o;    } catch (InstantiationException e) {        throw new RuntimeException(e);    } catch (IllegalAccessException e) {        throw new RuntimeException(e);    } catch (InvocationTargetException e) {        throw new RuntimeException(e);    } catch (NoSuchMethodException e) {        throw new RuntimeException(e);    }}

package com.heihu577.annotations;import java.lang.annotation.*;@Target(ElementType.FIELD) // 作用于成员属性上@Retention(RetentionPolicy.RUNTIME)public @interface Autowired {    boolean required() default true;}

@Componentpublic class MonsterDAO {    public void sayHello() {        System.out.println("MonsterDAO Hello World");    }}

@Scope("prototype")@Component(value = "monsterService") // 将 MonsterService 注入到容器中public class MonsterService {    @Autowired    private MonsterDAO monsterDAO;    public void sayHello() {        monsterDAO.sayHello();    }}

private Object createBean(BeanDefinition beanDefinition) {    Class<?> clazz = beanDefinition.getClazz();    try {        Object o = clazz.getDeclaredConstructor().newInstance();        Field[] declaredFields = clazz.getDeclaredFields();        for (Field declaredField : declaredFields) {            if (declaredField.isAnnotationPresent(Autowired.class)) { // 如果该字段被 Autowired 所修饰                String fieldName = declaredField.getName(); // 得到字段名称                Object bean = getBean(fieldName); // 通过 getBean 得到该对象 (根据字段名称查找)                declaredField.setAccessible(true);                declaredField.set(o, bean); // 将该字段的值设置为该 bean 对象            }        }        return o;    } catch (InstantiationException e) {        throw new RuntimeException(e);    } catch (IllegalAccessException e) {        throw new RuntimeException(e);    } catch (InvocationTargetException e) {        throw new RuntimeException(e);    } catch (NoSuchMethodException e) {        throw new RuntimeException(e);    }}public Object getBean(String name) {    if (beanDefinitionMap.containsKey(name)) {        BeanDefinition beanDefinition = beanDefinitionMap.get(name);        String scope = beanDefinition.getScope();        if ("singleton".equalsIgnoreCase(scope)) {            return singletonObject.get(name);        } else {            return createBean(beanDefinition);        }    } else {        throw new NullPointerException("该 bean 不存在!");    }}

public class T {    public static void main(String[] args) {        HeihuSpringApplicationContext heihuSpringApplicationContext = new HeihuSpringApplicationContext(HeihuSpringConfig.class);        MonsterService monsterService = (MonsterService) heihuSpringApplicationContext.getBean("monsterService");        monsterService.sayHello();        /*            要扫描的包: com/heihu577/components            是 Bean: class com.heihu577.components.MonsterDAO            是 Bean: class com.heihu577.components.MonsterService            不是 Bean: class com.heihu577.components.NoBean            MonsterDAO Hello World        */    }}

package com.heihu577.processor;public interface InitializingBean {    // 根据原生 spring, 定义了该接口, 该接口有一个方法    void afterPropertiesSet() throws Exception; // 在 Bean 的 setter 方法后执行}

@Componentpublic class MonsterDAO implements InitializingBean {    public void sayHello() {        System.out.println("MonsterDAO Hello World");    }    @Override    public void afterPropertiesSet() throws Exception {        System.out.println("afterPropertiesSet MonsterDAO Hi");    }}

private Object createBean(BeanDefinition beanDefinition) {    Class<?> clazz = beanDefinition.getClazz();    try {        Object o = clazz.getDeclaredConstructor().newInstance();        Field[] declaredFields = clazz.getDeclaredFields();        for (Field declaredField : declaredFields) {            if (declaredField.isAnnotationPresent(Autowired.class)) { // 如果该字段被 Autowired 所修饰                String fieldName = declaredField.getName(); // 得到字段名称                Object bean = getBean(fieldName); // 通过 getBean 得到该对象 (根据字段名称查找)                declaredField.setAccessible(true);                declaredField.set(o, bean); // 将该字段的值设置为该 bean 对象            }        }        if (o instanceof InitializingBean) {            // 如果实现 InitializingBean 接口, 那么就直接调用 afterPropertiesSet            ((InitializingBean) o).afterPropertiesSet();        }        return o;    } catch (InstantiationException e) {        throw new RuntimeException(e);    } catch (IllegalAccessException e) {        throw new RuntimeException(e);    } catch (InvocationTargetException e) {        throw new RuntimeException(e);    } catch (NoSuchMethodException e) {        throw new RuntimeException(e);    } catch (Exception e) {        throw new RuntimeException(e);    }}

public class T2 {    public static void main(String[] args) {        HeihuSpringApplicationContext heihuSpringApplicationContext = new HeihuSpringApplicationContext(HeihuSpringConfig.class);        MonsterDAO monsterDAO = (MonsterDAO) heihuSpringApplicationContext.getBean("monsterDAO");        monsterDAO.sayHello();        /*            要扫描的包: com/heihu577/components            是 Bean: class com.heihu577.components.MonsterDAO            是 Bean: class com.heihu577.components.MonsterService            不是 Bean: class com.heihu577.components.NoBean            afterPropertiesSet MonsterDAO Hi            MonsterDAO Hello World        */    }}

@Componentpublic interface BeanPostProcessor {    @Nullable    default Object postProcessBeforeInitialization(Object bean, String beanName) {        return bean;    }    @Nullable    default Object postProcessAfterInitialization(Object bean, String beanName)  {        return bean;    }}

@Componentpublic class HeihuBeanPostProcessor implements BeanPostProcessor {    public Object postProcessBeforeInitialization(Object bean, String beanName) {        System.out.println("HeihuBeanPostProcessor postProcessBeforeInitialization... " + beanName);        return bean;    }    public Object postProcessAfterInitialization(Object bean, String beanName)  {        System.out.println("HeihuBeanPostProcessor postProcessAfterInitialization... " + beanName);        return bean;    }}

private List<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();

String className = f.getName().replace(".class", "");String fullCLassPath = (classPath + "/" + className).replace("/", "."); // 再转换回来, 得到包名+类名try {    Class<?> clazz = Class.forName(fullCLassPath);    if (clazz.isAnnotationPresent(Component.class)) {        if (BeanPostProcessor.class.isAssignableFrom(clazz)) {            // 这个类实现了 BeanPostProcessor 接口            BeanPostProcessor beanPostProcessor = (BeanPostProcessor) clazz.getDeclaredConstructor().newInstance();            beanPostProcessorList.add(beanPostProcessor); // 加入到我们的 beanPostProcessorList 容器中            continue; // 直接进入下一跳. 单独放到ArrayList中即可        }

for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {    o = beanPostProcessor.postProcessBeforeInitialization(o, "..."); // 前置}if (o instanceof InitializingBean) {    ((InitializingBean) o).afterPropertiesSet(); // 初始化}for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {    o = beanPostProcessor.postProcessAfterInitialization(o, "..."); // 后置}return o;

public class T2 {    public static void main(String[] args) {        HeihuSpringApplicationContext heihuSpringApplicationContext = new HeihuSpringApplicationContext(HeihuSpringConfig.class);        MonsterDAO monsterDAO = (MonsterDAO) heihuSpringApplicationContext.getBean("monsterDAO");        monsterDAO.sayHello();        /*HeihuBeanPostProcessor postProcessBeforeInitialization... com.heihu577.components.MonsterDAO@66d3c617afterPropertiesSet MonsterDAO HiHeihuBeanPostProcessor postProcessAfterInitialization... com.heihu577.components.MonsterDAO@66d3c617MonsterDAO Hello World        */    }}

public String getKeyBybeanDefinitionMap(BeanDefinition beanDefinition) {    Set<Map.Entry<String, BeanDefinition>> entries = beanDefinitionMap.entrySet();    for (Map.Entry<String, BeanDefinition> entry : entries) {        BeanDefinition dstBeanDefinition = entry.getValue();        if (dstBeanDefinition == beanDefinition) { // 比较是否是同一对象            return entry.getKey();        }    }    return null;}

String beanName = getKeyBybeanDefinitionMap(beanDefinition);for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {    o = beanPostProcessor.postProcessBeforeInitialization(o, beanName);}if (o instanceof InitializingBean) {    // 如果实现 InitializingBean 接口, 那么就直接调用 afterPropertiesSet    ((InitializingBean) o).afterPropertiesSet();}for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {    o = beanPostProcessor.postProcessAfterInitialization(o, beanName);}

for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {    Object o1 = beanPostProcessor.postProcessBeforeInitialization(o, beanName);    if (o1 == null) {        continue;    } else {        o = o1;    }}if (o instanceof InitializingBean) {    // 如果实现 InitializingBean 接口, 那么就直接调用 afterPropertiesSet    ((InitializingBean) o).afterPropertiesSet();}for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {    Object o1 = beanPostProcessor.postProcessAfterInitialization(o, beanName);    if (o1 == null) {        continue;    } else {        o = o1;    }}return o;

public interface IUsb {    public void start();    public void pringMsg(String msg);    public String getName();}

@Componentpublic class MyUsb implements IUsb{    @Override    public void start() {        System.out.println("MyUsb start...");    }    @Override    public void pringMsg(String msg) {        System.out.println(msg);    }    @Override    public String getName() {        return "手机";    }}

public class UsbAspect {    public static void beforeTest() { // 前置通知        System.out.println("UsbAspect before...");    }    public static void afterTest() { // 后置通知        System.out.println("UsbAspect after...");    }}

@Componentpublic class HeihuBeanPostProcessor implements BeanPostProcessor {    public Object postProcessBeforeInitialization(Object bean, String beanName) {//        if (bean instanceof MonsterService) {//            System.out.println("这是 Monster Service");//        }        System.out.println("HeihuBeanPostProcessor postProcessBeforeInitialization... " + bean + " - " + beanName);        return bean;    }    public Object postProcessAfterInitialization(Object bean, String beanName) {        System.out.println("HeihuBeanPostProcessor postProcessAfterInitialization... " + bean + " - " + beanName);        // 先死后活        if ("myUsb".equals(beanName)) { // 假设被切面的对象是 myUsb            Object proxyInstance = Proxy.newProxyInstance(HeihuBeanPostProcessor.class.getClassLoader(),                    bean.getClass().getInterfaces(),                    new InvocationHandler() {                        @Override                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                            Object result = null;                            if ("start".equals(method.getName())) { // 假设要切面 start 方法                                UsbAspect.beforeTest();                                method.invoke(bean, args);                                UsbAspect.afterTest();                            } else {                                result = method.invoke(bean, args);                            }                            return result;                        }                    });            return proxyInstance;        }        return bean;    }}

public class T2 {    public static void main(String[] args) {        HeihuSpringApplicationContext heihuSpringApplicationContext = new HeihuSpringApplicationContext(HeihuSpringConfig.class);        IUsb myUsb = (IUsb) heihuSpringApplicationContext.getBean("myUsb");        myUsb.start();        /*            UsbAspect before...            MyUsb start...            UsbAspect after...        */    }}

<dependencies>    <!-- c3p0 -->    <dependency>        <groupId>c3p0</groupId>        <artifactId>c3p0</artifactId>        <version>0.9.1.2</version>    </dependency>    <!-- MySQL Connector/J -->    <dependency>        <groupId>mysql</groupId>        <artifactId>mysql-connector-java</artifactId>        <version>8.0.25</version>    </dependency>    <!-- Spring Core -->    <dependency>        <groupId>org.springframework</groupId>        <artifactId>spring-core</artifactId>        <version>5.3.8</version>    </dependency>    <!-- Spring Expression Language (SpEL) -->    <dependency>        <groupId>org.springframework</groupId>        <artifactId>spring-expression</artifactId>        <version>5.3.8</version>    </dependency>    <!-- Spring JDBC -->    <dependency>        <groupId>org.springframework</groupId>        <artifactId>spring-jdbc</artifactId>        <version>5.3.8</version>    </dependency>    <!-- Spring ORM -->    <dependency>        <groupId>org.springframework</groupId>        <artifactId>spring-orm</artifactId>        <version>5.3.8</version>    </dependency>    <!-- Spring Transaction Management -->    <dependency>        <groupId>org.springframework</groupId>        <artifactId>spring-tx</artifactId>        <version>5.3.8</version>    </dependency>    <dependency> <!-- 加入 Spring 开发的基本包 -->        <groupId>org.springframework</groupId>        <artifactId>spring-context</artifactId>        <version>5.3.8</version>    </dependency>    <dependency> <!-- 加入 Spring 开发切面编程需要的包 -->        <groupId>org.springframework</groupId>        <artifactId>spring-aspects</artifactId>        <version>5.3.8</version>    </dependency>    <dependency> <!-- 引入 Junit 单元测试 -->        <groupId>junit</groupId>        <artifactId>junit</artifactId>        <version>4.7</version>        <scope>compile</scope>    </dependency></dependencies>

CREATE DATABASE `spring`;use `spring`;CREATE TABLE `monster`(    id int primary key,    `name` varchar(64) not null default '',    skill varchar(64) not null default '')charset=utf8;INSERT INTO `monster` VALUES(100, '黄牛怪', '吐火');INSERT INTO `monster` VALUES(200, '黄袍怪', '吐烟');INSERT INTO `monster` VALUES(300, '蜘蛛怪', '吐丝');

jdbc.userName=rootjdbc.password=rootjdbc.driverClass=com.mysql.cj.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/spring

<context:property-placeholder location="classpath:jdbc.properties"/> <!-- 引入 JDBC 配置文件 --><bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">    <!-- 配置 c3p0 的数据源, 是属于 c3p0 开发的配置 -->    <property name="user" value="${jdbc.userName}"/>    <property name="password" value="${jdbc.password}"/>    <property name="driverClass" value="${jdbc.driverClass}"/>    <property name="jdbcUrl" value="${jdbc.url}"/></bean><bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">    <!-- 配置 jdbcTemplate, 是属于 spring 开发的配置对象, 给 jdbcTemplate 配置数据池 -->    <property name="dataSource" ref="dataSource"/></bean>

public class T {    private ApplicationContext ioc2 = new ClassPathXmlApplicationContext("jdbcTemplateIoc.xml");    @Test    public void t2() throws SQLException {        DataSource dataSource = (DataSource) ioc2.getBean("dataSource");        System.out.println(dataSource); // 链接成功信息        Connection connection = dataSource.getConnection();        System.out.println("连接信息: " + connection); //  com.mchange.v2.c3p0.impl.NewProxyConnection@3b2cf7ab    }}

public void t3() throws SQLException {    JdbcTemplate jdbcTemplate = (JdbcTemplate) ioc2.getBean("jdbcTemplate");    // System.out.println(jdbcTemplate); // org.springframework.jdbc.core.JdbcTemplate@143640d5    // 添加方式1: 无预处理    jdbcTemplate.execute("INSERT INTO `spring`.`monster` VALUES(400, '张三', '吃饭')"); // 无返回值    // 添加方式2: 预处理    int affected = jdbcTemplate.update("INSERT INTO `spring`.`monster` VALUES(?,?,?)", 500, "李四", "吃饭"); // 返回受影响的行数    System.out.println(affected); // 1}

@Testpublic void t4() {    JdbcTemplate jdbcTemplate = ioc2.getBean(JdbcTemplate.class);    String sql = "INSERT INTO `monster` VALUES(?,?,?)"; // 准备 SQL 语句    List<Object[]> param_list = new ArrayList<>(); // 准备好预处理数组    param_list.add(new Object[]{600, "王五", "打架"}); // 第一组数据    param_list.add(new Object[]{700, "赵六", "挨打"}); // 第二组数据    int[] result = jdbcTemplate.batchUpdate(sql, param_list); // 批量执行    System.out.println(Arrays.toString(result)); // [1, 1] 执行成功}

@Testpublic void t5() {    JdbcTemplate bean = ioc2.getBean(JdbcTemplate.class);    String sql = "SELECT * FROM `monster` WHERE id > ?";    BeanPropertyRowMapper<Monster> monsterBeanPropertyRowMapper = new BeanPropertyRowMapper<>(Monster.class);    // 准备好 Mapper 才可以进行绑定数据到 Bean 上    List<Monster> result = bean.query(sql, monsterBeanPropertyRowMapper, 200);    // SQL语句, Mapper, 绑定的参数    System.out.println(result);    /*        [Monster{id=300, name='蜘蛛怪', skill='吐丝'}, Monster{id=400, name='张三', skill='吃饭'}, Monster{id=500, name='李四', skill='吃饭'}, Monster{id=600, name='王五', skill='打架'}, Monster{id=700, name='赵六', skill='挨打'}]    */}

@Testpublic void t6() {    JdbcTemplate bean = ioc2.getBean(JdbcTemplate.class);    String sql = "SELECT name FROM `monster` WHERE id = ?";    String name = bean.queryForObject(sql, String.class, 100);    System.out.println(name); // 黄牛怪}

<bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">    <!-- 配置 namedParameterJdbcTemplate, 设置为 c3p0 的连接池 -->    <constructor-arg name="dataSource" ref="dataSource"/></bean>

@Testpublic void t7() {    NamedParameterJdbcTemplate namedParameterJdbcTemplate = ioc2.getBean(NamedParameterJdbcTemplate.class);    // 这次不用 JdbcTemplate, 而是 NamedParameterJdbcTemplate 需要注意    String sql = "INSERT INTO `monster` VALUES(:my_id, :name, :skill)";    HashMap<String, Object> map_parameter = new HashMap<>();    map_parameter.put("my_id", 1000); // 放置的KEY与占位符名称相同    map_parameter.put("name", "黑客"); // 放置的KEY与占位符名称相同    map_parameter.put("skill", "进局子"); // 放置的KEY与占位符名称相同    int result = namedParameterJdbcTemplate.update(sql, map_parameter);    System.out.println(result); // 1}

@Testpublic void t8() {    NamedParameterJdbcTemplate namedParameterJdbcTemplate = ioc2.getBean(NamedParameterJdbcTemplate.class);    Monster monster = new Monster(900, "牛逼怪物", "大相机");    int update = namedParameterJdbcTemplate.update("INSERT INTO `monster` VALUES(:id,:name,:skill)",            // 这里要与monster类中的字段对应   new BeanPropertySqlParameterSource(monster)); // 传入我们准备的对象    System.out.println(update);}

@Repository // DAO 使用 Repositorypublic class MonsterDAO {    @Autowired // JdbcTemplate 使用 Autowired 自动装配    private JdbcTemplate jdbcTemplate;    public boolean save(Monster monster) {        String sql = "INSERT INTO `monster` VALUES(?,?,?)";        return jdbcTemplate.update(sql, monster.getId(), monster.getName(), monster.getSkill()) > 0;    }    public List<Monster> showMonsters() {        String sql = "SELECT * FROM `monster`";        List<Monster> monsters = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Monster.class));        return monsters;    }}

<context:component-scan base-package="com.heihu577.JdbcTemplate"/> <!-- 扫描到我们的 monsterDAO --><context:property-placeholder location="classpath:jdbc.properties"/> <!-- 引入 JDBC 配置文件 --><bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">    <!-- 配置 c3p0 的数据源, 是属于 c3p0 开发的配置 -->    <property name="user" value="${jdbc.userName}"/>    <property name="password" value="${jdbc.password}"/>    <property name="driverClass" value="${jdbc.driverClass}"/>    <property name="jdbcUrl" value="${jdbc.url}"/></bean><bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">    <!-- 配置 jdbcTemplate, 是属于 spring 开发的配置对象, 给 jdbcTemplate 配置数据池 -->    <property name="dataSource" ref="dataSource"/></bean><bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">    <!-- 配置 namedParameterJdbcTemplate, 设置为 c3p0 的连接池 -->    <constructor-arg name="dataSource" ref="dataSource"/></bean>

@Testpublic void t9() {    MonsterDAO monsterDAO = ioc2.getBean(MonsterDAO.class);    List<Monster> monsters = monsterDAO.showMonsters();    System.out.println(monsters);    /*        [Monster{id=100, name='黄牛怪', skill='吐火'}, Monster{id=200, name='黄袍怪', skill='吐烟'}, Monster{id=300, name='蜘蛛怪', skill='吐丝'}, Monster{id=400, name='张三', skill='吃饭'}, Monster{id=500, name='李四', skill='吃饭'}, Monster{id=700, name='赵六', skill='挨打'}, Monster{id=600, name='王五', skill='打架'}, Monster{id=1000, name='黑客', skill='进局子'}, Monster{id=900, name='牛逼怪物', skill='大相机'}]    */}

CREATE TABLE `user_account`(    user_id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,    user_name VARCHAR(32) NOT NULL DEFAULT '',    money DOUBLE NOT NULL DEFAULT 0.0)CHARSET=utf8;INSERT INTO `user_account` VALUES(NULL,'张三', 1000);INSERT INTO `user_account` VALUES(NULL,'李四', 2000);CREATE TABLE `goods`(    goods_id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,    goods_name VARCHAR(32) NOT NULL DEFAULT '',    price DOUBLE NOT NULL DEFAULT 0.0)CHARSET=utf8 ;INSERT INTO `goods` VALUES(NULL,'小风扇', 10.00);INSERT INTO `goods` VALUES(NULL,'小台灯', 12.00);INSERT INTO `goods` VALUES(NULL,'可口可乐', 3.00);CREATE TABLE `goods_amount`(    goods_id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,    goods_num INT UNSIGNED DEFAULT 0)CHARSET=utf8 ;INSERT INTO `goods_amount` VALUES(1,200);INSERT INTO `goods_amount` VALUES(2,20);INSERT INTO `goods_amount` VALUES(3,15);

@Repositorypublic class GoodsDAO {    @Autowired    private JdbcTemplate jdbcTemplate;    public Float queryPriceById(Integer id) { // 根据ID查询出商品价格        String sql = "SELECT price From goods Where goods_id=?";        Float price = jdbcTemplate.queryForObject(sql, Float.class, id);        return price;    }    public void updateBalance(Integer user_id, Float money) { // 减少用户余额        String sql = "UPDATE user_account SET money=money-? Where user_id=?";        jdbcTemplate.update(sql, money, user_id);    }    public void updateAmount(Integer goods_id, int amount) { // 修改商品库存        String sql = "UPDATE goods_amount SET goods_num=goods_num-? Where goods_id=?";        jdbcTemplate.update(sql, amount, goods_id);    }}

<context:property-placeholder location="classpath:jdbc.properties"/> <!-- 加载配置文件, 得用户名, 密码等信息 --><context:component-scan base-package="com.heihu577.JdbcTemplate02"/> <!-- 将 GoodsDAO 等 Spring Bean 扫描到 --><bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <!-- 配置数据库连接池 -->    <property name="user" value="${jdbc.userName}"/>    <property name="password" value="${jdbc.password}"/>    <property name="driverClass" value="${jdbc.driverClass}"/>    <property name="jdbcUrl" value="${jdbc.url}"/></bean><bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">    <!-- 配置 jdbcTemplate, 是属于 spring 开发的配置对象, 给 jdbcTemplate 配置数据池 -->    <property name="dataSource" ref="dataSource"/></bean>

public class TestGoodsDAO {    private ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplateIoc02.xml");    private GoodsDAO goodsDAO = ioc.getBean(GoodsDAO.class);    @Test    public void testQueryPriceById() { // 测试查询根据商品ID得到价格信息        /*        *   +----------+--------------+-------+            | goods_id | goods_name   | price |            +----------+--------------+-------+            |        1 | 小风扇       |    10 |            |        2 | 小台灯       |    12 |            |        3 | 可口可乐     |     3 |            +----------+--------------+-------+        * */        Float price = goodsDAO.queryPriceById(1);        System.out.println("ID 为 1 的商品价格: " + price); // ID 为 1 的商品价格: 10.0    }    @Test    public void testUpdateAmount() { // 测试减少商品数量        /*        * 原本:        *   +----------+-----------+            | goods_id | goods_num |            +----------+-----------+            |        1 |       200 |            |        2 |        20 |            |        3 |        15 |            +----------+-----------+        * */        goodsDAO.updateAmount(1, 10); // goods_id 为 1 的商品数量减少10个        /*        * 执行结果后        *   +----------+-----------+            | goods_id | goods_num |            +----------+-----------+            |        1 |       190 |            |        2 |        20 |            |        3 |        15 |            +----------+-----------+        * */    }    @Test    public void testUpdateBalance() {        /* 原本:        *   +---------+-----------+-------+            | user_id | user_name | money |            +---------+-----------+-------+            |       1 | 张三      |  1000 |            |       2 | 李四      |  2000 |            +---------+-----------+-------+        * */        goodsDAO.updateBalance(1, 10.0f); // user_id 为 1 的 money 字段减少 10        /* 现在:        *   +---------+-----------+-------+            | user_id | user_name | money |            +---------+-----------+-------+            |       1 | 张三      |   990 |            |       2 | 李四      |  2000 |            +---------+-----------+-------+        * */    }}

@Servicepublic class GoodsService {    @Resource    private GoodsDAO goodsDAO;    public void buyGood(int userId, int goods_id, int amount) { // 用户ID 商品ID 购买数量        System.out.println("用户ID号为 " + userId + " 购买了商品ID为 " + goods_id + " 数量为 " + amount);        Float price = goodsDAO.queryPriceById(userId); // 得到当前用户余额        goodsDAO.updateBalance(userId, price * amount); // 用户的余额 - 商品单价 * 购买数量        goodsDAO.updateAmount(goods_id, amount); // 商品减少库存量        System.out.println("用户购买成功~");    }}

public class TestGoodsDAO {    private ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplateIoc02.xml");    private GoodsDAO goodsDAO = ioc.getBean(GoodsDAO.class);    private GoodsService goodsService = ioc.getBean(GoodsService.class);    @Test    public void testBuyGoods() {        /*        * mysql> SELECT * FROM goods;                +----------+--------------+-------+                | goods_id | goods_name   | price |                +----------+--------------+-------+                |        1 | 小风扇       |    10 |                |        2 | 小台灯       |    12 |                |        3 | 可口可乐     |     3 |                +----------+--------------+-------+                3 rows in set (0.00 sec)                mysql> SELECT * FROM goods_amount;                +----------+-----------+                | goods_id | goods_num |                +----------+-----------+                |        1 |       190 |                |        2 |        20 |                |        3 |        15 |                +----------+-----------+                3 rows in set (0.00 sec)                mysql> SELECT * FROM user_account;                +---------+-----------+-------+                | user_id | user_name | money |                +---------+-----------+-------+                |       1 | 张三      |   990 |                |       2 | 李四      |  2000 |                +---------+-----------+-------+                2 rows in set (0.00 sec)        * */        goodsService.buyGood(2, 2, 2); // 用户ID号为 2 购买了商品ID为 2 数量为 2        /*        * mysql> SELECT * FROM goods;                +----------+--------------+-------+                | goods_id | goods_name   | price |                +----------+--------------+-------+                |        1 | 小风扇       |    10 |                |        2 | 小台灯       |    12 |                |        3 | 可口可乐     |     3 |                +----------+--------------+-------+                3 rows in set (0.00 sec)                mysql> SELECT * FROM goods_amount;                +----------+-----------+                | goods_id | goods_num |                +----------+-----------+                |        1 |       190 |                |        2 |        18 |                |        3 |        15 |                +----------+-----------+                3 rows in set (0.00 sec)                mysql> SELECT * FROM user_account;                +---------+-----------+-------+                | user_id | user_name | money |                +---------+-----------+-------+                |       1 | 张三      |   990 |                |       2 | 李四      |  1976 |                +---------+-----------+-------+                2 rows in set (0.00 sec)        * */    }}

@Servicepublic class GoodsService {    @Resource    private GoodsDAO goodsDAO;    @Transactional // 加入想要一并执行的注解    public void buyGoodByTx(int userId, int goods_id, int amount) { // 用户ID 商品ID 购买数量        System.out.println("用户ID号为 " + userId + " 购买了商品ID为 " + goods_id + " 数量为 " + amount);        Float price = goodsDAO.queryPriceById(userId); // 得到当前用户余额        goodsDAO.updateBalance(userId, price * amount); // 用户的余额 - 商品单价 * 购买数量        goodsDAO.updateAmount(goods_id, amount); // 商品减少库存量        System.out.println("用户购买成功~");    }}

<bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="dataSourceTransactionManager">    <!-- 必须配置该bean, 否则事务不生效 -->    <property name="dataSource" ref="dataSource"/></bean><tx:annotation-driven transaction-manager="dataSourceTransactionManager"/> <!-- 并且配置启用标签, 类似于AOP中的aop标签 -->

@Repositorypublic class GoodsDAO {    @Autowired    private JdbcTemplate jdbcTemplate;    public Float queryPriceById(Integer id) { // 根据ID查询出商品价格        String sql = "SELECT price From goods Where goods_id=?";        Float price = jdbcTemplate.queryForObject(sql, Float.class, id);        return price;    }    public void updateBalance(Integer user_id, Float money) { // 减少用户余额        String sql = "UPDATE user_account SET money=money-? Where user_id=?";        jdbcTemplate.update(sql, money, user_id);    }    public void updateAmount(Integer goods_id, int amount) { // 修改商品库存        String sql = "UPDATEX goods_amount SET goods_num=goods_num-? Where goods_id=?"; // 这里故意搞错        jdbcTemplate.update(sql, amount, goods_id);    }}

@Transactional(propagation=Propagation.REQUIRED)

@Repositorypublic class GoodsDAO {    @Autowired    private JdbcTemplate jdbcTemplate;    public Float queryPriceById(Integer id) { // 根据ID查询出商品价格        String sql = "SELECT price From goods Where goods_id=?";        Float price = jdbcTemplate.queryForObject(sql, Float.class, id);        return price;    }    public void updateBalance(Integer user_id, Float money) { // 减少用户余额        String sql = "UPDATE user_account SET money=money-? Where user_id=?";        jdbcTemplate.update(sql, money, user_id);    }    public void updateAmount(Integer goods_id, int amount) { // 修改商品库存        String sql = "UPDATE goods_amount SET goods_num=goods_num-? Where goods_id=?";        jdbcTemplate.update(sql, amount, goods_id);    }    public Float queryPriceById2(Integer id) { // 根据ID查询出商品价格        String sql = "SELECT price From goods Where goods_id=?";        Float price = jdbcTemplate.queryForObject(sql, Float.class, id);        return price;    }    public void updateBalance2(Integer user_id, Float money) { // 减少用户余额        String sql = "UPDATE user_account SET money=money-? Where user_id=?";        jdbcTemplate.update(sql, money, user_id);    }    public void updateAmount2(Integer goods_id, int amount) { // 修改商品库存        String sql = "UPDATEX goods_amount SET goods_num=goods_num-? Where goods_id=?"; // 这里放置一个错误的SQL语句        jdbcTemplate.update(sql, amount, goods_id);    }}

@Servicepublic class GoodsService {    @Resource    private GoodsDAO goodsDAO;    public void buyGood(int userId, int goods_id, int amount) { // 用户ID 商品ID 购买数量        System.out.println("用户ID号为 " + userId + " 购买了商品ID为 " + goods_id + " 数量为 " + amount);        Float price = goodsDAO.queryPriceById(userId); // 得到当前用户余额        goodsDAO.updateBalance(userId, price * amount); // 用户的余额 - 商品单价 * 购买数量        goodsDAO.updateAmount(goods_id, amount); // 商品减少库存量        System.out.println("用户购买成功~");    }    @Transactional    public void buyGoodByTx(int userId, int goods_id, int amount) { // 用户ID 商品ID 购买数量        System.out.println("用户ID号为 " + userId + " 购买了商品ID为 " + goods_id + " 数量为 " + amount);        Float price = goodsDAO.queryPriceById(userId); // 得到当前用户余额        goodsDAO.updateBalance(userId, price * amount); // 用户的余额 - 商品单价 * 购买数量        goodsDAO.updateAmount(goods_id, amount); // 商品减少库存量        System.out.println("用户购买成功~");    }    @Transactional    public void buyGoodByTx2(int userId, int goods_id, int amount) {        System.out.println("用户ID号为 " + userId + " 购买了商品ID为 " + goods_id + " 数量为 " + amount);        Float price = goodsDAO.queryPriceById2(userId); // 得到当前用户余额        goodsDAO.updateBalance2(userId, price * amount); // 用户的余额 - 商品单价 * 购买数量        goodsDAO.updateAmount2(goods_id, amount); // 商品减少库存量        System.out.println("用户购买成功~");    }}

@Componentpublic class MultiplyService {    @Autowired    private GoodsService goodsService;    @Transactional    public void multiBuyGoodsTx() {        goodsService.buyGoodByTx(1, 1, 1); // 正常运行        goodsService.buyGoodByTx2(2, 1, 2); // 报错, 运行不了    }}

@Testpublic void t10() {    MultiplyService multiplyService = ioc2.getBean(MultiplyService.class);    multiplyService.multiBuyGoodsTx(); // JAVA控制台显示出错, 但 Mysql 的数据并没被 buyGoodByTx 影响, 也就是, multiBuyGoodsTx 若出现错误, 那么该方法中的所有方法统一进行回滚.}

@Transactional(propagation = Propagation.REQUIRES_NEW)public void buyGoodByTx(int userId, int goods_id, int amount) { // 用户ID 商品ID 购买数量    System.out.println("用户ID号为 " + userId + " 购买了商品ID为 " + goods_id + " 数量为 " + amount);    Float price = goodsDAO.queryPriceById(userId); // 得到当前用户余额    goodsDAO.updateBalance(userId, price * amount); // 用户的余额 - 商品单价 * 购买数量    goodsDAO.updateAmount(goods_id, amount); // 商品减少库存量    System.out.println("用户购买成功~");}@Transactional(propagation = Propagation.REQUIRES_NEW)public void buyGoodByTx2(int userId, int goods_id, int amount) {    System.out.println("用户ID号为 " + userId + " 购买了商品ID为 " + goods_id + " 数量为 " + amount);    Float price = goodsDAO.queryPriceById2(userId); // 得到当前用户余额    goodsDAO.updateBalance2(userId, price * amount); // 用户的余额 - 商品单价 * 购买数量    goodsDAO.updateAmount2(goods_id, amount); // 商品减少库存量    System.out.println("用户购买成功~");}