@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

              //1.创建真正的Spring容器（DefaultListableBeanFactory）
              //2.加载BeanDefition（描述要初始化的Bean的信息）
              //3.将BeanDefition注册到BeanDefitionRegistry
            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                  //执行实现了BeanFactoryPostProcessor接口的Bean
                  //比如PropertyPlaceHolderConfigurer（context:property-placeholer）就是此处被调用的，替换掉BeanDefition中的占位符（${}）中的内容
                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                  //注册BeanPostProcessor（后置处理器）
                  //比如容器自动装载了一个AutowiredAnnotationBeanPostProcessor后置处理器（实现@Autowired注解功能）
                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                  //初始化非懒加载方式的单例Bean实例
                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset ‘active‘ flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring‘s core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.kkb</groupId>
    <artifactId>spring</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <dependencies>
        <!-- spring 核心组件中的4个依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>

         <!-- 单元测试Junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 配置Maven的JDK编译级别 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

<?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">

</beans>

<bean id="userService" class="com.chenyanbin.spring.service.UserServiceImpl">

/**
* 模拟一个静态工厂，创建业务层实现类
*/
public class StaticFactory {
　　public static UserService createUserService(){
　　　　return new UserServiceImpl();
　　}
}

<!--此种方法时：  
使用StaticFactory类中的静态方法createUserService创建对象，并存入Spring容器
id属性：指定bean的id，用于从容器中获取
class属性：指定静态工厂的全限定类名
factory-method属性：指定生产对象的静态方法
-->
<bean id="userService" class="com.chenyanbin.spring.factory.StaticFactory" factory-method="createUserService"></bean>

/**
*    模拟一个实例工厂，创建业务层实现类
*    此工厂创建对象，必须现有工厂实例对象，再调用方法
*/
public class InstanceFactory {
    public UserService createUserService(){
        return new UserServiceImpl();
    } 
}

<!--
此种方式是：
    先把工厂的创建交给spring来管理。
    然后在使用工厂的bean来调用里面的方法
        factory-ben属性：用于指定实例工厂bean的id。
        factory-method属性：用于指定实例工厂中创建对象的方法。
-->
<bean id="instanceFactory" class="com.chenyanbin.factory.InstanceFactory"></bean>
<bean id="userService" factory-bean="instanceFactory" factory-method="createUserService"></bean>

public class UserServiceImpl implements UserService {
    private int id;
    private String name;
    
    public UserServiceImpl(int id, String name) {
        this.id = id;
        this.name = name;
    }
    @Override
    public void saveUser() {
        System.out.println("保存用户:id为"+id+"，name为"+name+"   Service实现");
    }
}

<!--使用构造函数的方式，给Service中的属性传值要求：类中需要提供一个对应参数列表的构造函数。
        涉及的标签：constructor-arg
            index：指定参数在构造函数参数列表的索引位置
            name：指定参数在构造函数中的名称
            value：它能赋的值是基本数据类型和String类型
            ref：他能赋的值是其他bean类型，也就是说，必须得是在配置文件中配置过的bean
--> 
<bean id="userService" class="com.chenyanbin.spring.service.UserServiceImpl">
    <constructor-arg name="id" value="1"></constructor-arg>
    <constructor-arg name="name" value="zhangsan"></constructor-arg>
</bean>

xmlns:p="http://www.springframework.org/schema/p"

p:属性名=""
p:属性名-ref=""

<bean id="person" class="com.chenyanbin.spring.demo.Person" p:pname="隔壁老王" p:car2-ref="car2" />
<bean id="car2" class="com.chenyanbin.spring.demo.Car2" />

<bean id="userService" class="com.chenyanbin.spring.service.UserServiceImpl">
    <property name="id" value="1"></property>
    <property name="name" value="zhangsan"></property>
</bean>

<bean id="userService" class="com.chenyanbin.spring.service.UserServiceImpl">
    <property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.chenyanbin.spring.dao.UserDaoImpl"></bean>

<bean id="collectionBean" class="com.chenyanbin.demo5.CollectionBean">
    <property name="arrs">
        <list>
<!--如果集合内是简单类型，使用value子标签，如果是POJO类型，则使用bean标签-->
            <value>张三</value>
            <value>李四</value>
            <value>王五</value>
        </list>
    </property>
</bean>

<property name="sets">
    <set>
<!--如果集合内是简单类型，使用value子标签，如果是POJO类型，则使用bean标签-->
        <value>哈哈</value>
        <value>喜喜</value>
    </set>
</property>

<property name="map">
    <map>
        <entry key="老王" value="18" />
        <entry key="王五" value="19" />
    </map>
</property>

<property name="pro">
    <props>
        <prop key="userName">root</prop>
        <prop key="userPassword">123</prop>
    </props>
</property>

作用：
    把资源让Spring来管理。相当于在XML中配置一个bean。
属性：
    value：指定bean的id。
如果不指定value属性，默认bean的id时当前类的类型。首字母小写。

他们三个注解都是针对@Component的衍生注解
他们的作用及属性都是一摸一样的。他们只不过是提供了更加明确的语义化。
    @Controller：一般用于表现层的注解。
    @Service：一般用于业务层的注解。
    @Repository：一般用于持久层的注解。
细节：如果注解中有且只有一个属性要赋值时，且名称是value，value在赋值是可以不写。

<!--开启注解并扫描指定包中带有注解的类-->
<context:component-scan base-package="com.chenyanbin.spring.service" />

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" value="dataSource"></property>
</bean>

之前创建ApplicationContext都是通过读取XML文件进行创建的。
ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");

    @Configuration
    public class SpringConfiguration {
        //spring容器初始化时，会调用配置类的无参构造函数
        public SpringConfiguration(){
            System.out.println(“容器启动初始化。。。”);
        }
    }

public class SpringConfiguration {
        //spring容器初始化时，会调用配置类的无参构造函数
        public SpringConfiguration(){
            System.out.println(“容器启动初始化。。。”);
    }
    @Bean
    @Scope(“prototype”)
    public UserService userService(){
        return new UserServiceImpl(1,“张三”);
    }
}

@Service
public class UserServiceImpl implements UserService {
    @Override
    public void saveUser() {
        System.out.println("保存用户   Service实现");
    }
}

@Configuration
@ComponentScan(basePackages="com.kkb.spring.service")
public class SpringConfiguration {

    public SpringConfiguration() {
        System.out.println("容器初始化...");
    }
    
//    @Bean
//    @Scope("prototype")
//    public UserService userService() {
//        return new UserServiceImpl(1,"张三");
//    }
}

@Configuration
@PropertySource(“classpath:jdbc.properties”)
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

/**
*创建一个数据源，并存入 spring 容器中
*@return
*/
@Bean(name="dataSource")
public DataSource createDataSource() {
    try {
        ComboPooledDataSource ds = new ComboPooledDataSource();                     
        ds.setDriverClass(driver);
        ds.setJdbcUrl(url); 
        ds.setUser(username); 
        ds.setPassword(password); 
        return ds;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    }
}  

jdbc.driver=com.mysql.jdbc.Driver 
jdbc.url=jdbc:mysql:///spring
jdbc.username=root 
jdbc.password=root

@Configuration
@ComponentScan(basePackages = "com.kkb.spring")
@Import({ JdbcConfig.class})
public class SpringConfiguration {
}


@Configuration
@PropertySource("classpath:jdbc.properties")
    public class JdbcConfig{
}

ApplicationContext context = new    AnnotationConfigApplicationContext(SpringConfiguration.class);
UserService service = context.getBean(UserService.class);
service.saveUser();

<web-app>
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>
            org.springframework.web.context.
            support.AnnotationConfigWebApplicationContext
        </param-value>
    </context-param>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            com.kkb.spring.test.SpringConfiguration
        </param-value>
    </context-param>
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
</web-app>

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService service1 = context.getBean(UserService.class);

 /**
     * 使用JDK的方式生成代理对象
     * @author Administrator
     */
    public class MyProxyUtils {
        public static UserService getProxy(final UserService service) {
            // 使用Proxy类生成代理对象
            UserService proxy = 
                 (UserService) Proxy.newProxyInstance(
                    service.getClass().getClassLoader(),
                    service.getClass().getInterfaces(), 
                    new InvocationHandler() {

                        // 代理对象方法一执行，invoke方法就会执行一次
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                            if("save".equals(method.getName())){
                                System.out.println("记录日志...");
                                // 开启事务
                            }
                            // 提交事务
                            // 让service类的save或者update方法正常的执行下去
                            return method.invoke(service, args);
                        }
                    });
            // 返回代理对象
            return proxy;
        }
    }

  public static UserService getProxy(){
        // 创建CGLIB核心的类
        Enhancer enhancer = new Enhancer();
        // 设置父类
        enhancer.setSuperclass(UserServiceImpl.class);
        // 设置回调函数
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object obj, Method method, Object[] args,
                    MethodProxy methodProxy) throws Throwable {
                if("save".equals(method.getName())){
                    // 记录日志
                    System.out.println("记录日志了...");
                }
                return methodProxy.invokeSuper(obj, args);
            }
        });
        // 生成代理对象
        UserService proxy = (UserService) enhancer.create();
        return proxy;
    }

        <!-- 基于AspectJ的aop依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>

<context:component-scan back-package="com.chenyanbin.spring" />

    @Test
    public void run1(){
        // 创建连接池，先使用Spring框架内置的连接池
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///spring ");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        // 创建模板类
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        // 完成数据的添加
        jdbcTemplate.update("insert into t_account values (null,?,?)", "测试",10000);
    }

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql:///spring_day03"/>
    <property name="username" value="root"/>
    <property name="password" value="root"/>
</bean>

<bean  id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
</bean>

　　　　@RunWith(SpringJUnit4ClassRunner.class)
　　　　@ContextConfiguration("classpath:applicationContext.xml")
　　　　public class Demo2{
            @Resource(name="jdbcTemplate")
            private JdbcTemplate jdbcTemplate;

            @Test
            public void run(){
                jdbcTemplate.update("insert into t_account values (null,?,?)", "测试2",10000);
            }

　　　　}

    管理DBCP连接池
    * 先引入DBCP的2个jar包
        * com.springsource.org.apache.commons.dbcp-1.2.2.osgi.jar
        * com.springsource.org.apache.commons.pool-1.5.3.jar
        如果是maven环境，需要填写GAV坐标
    * 编写配置文件
        <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
            <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql:///spring "/>
            <property name="username" value="root"/>
            <property name="password" value="root"/>
        </bean>

    管理C3P0连接池
    * 先引入C3P0的jar包
        * com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar

    * 编写配置文件
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="driverClass" value="com.mysql.jdbc.Driver"/>
            <property name="jdbcUrl" value="jdbc:mysql:///spring"/>
            <property name="user" value="root"/>
            <property name="password" value="root"/>
        </bean>

    增删改查的操作
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class SpringDemo {

        @Resource(name="jdbcTemplate")
        private JdbcTemplate jdbcTemplate;

        @Test
        // 插入操作
        public void demo1(){
            jdbcTemplate.update("insert into account values (null,?,?)", "冠希",10000d);
        }

        @Test
        // 修改操作
        public void demo2(){
            jdbcTemplate.update("update account set name=?,money =? where id = ?", "思雨",10000d,5);
        }

        @Test
        // 删除操作
        public void demo3(){
            jdbcTemplate.update("delete from account where id = ?", 5);
        }

        @Test
        // 查询一条记录
        public void demo4(){
            Account account = jdbcTemplate.queryForObject("select * from account where id = ?", new BeanMapper(), 1);
            System.out.println(account);
        }

        @Test
        // 查询所有记录
        public void demo5(){
            List<Account> list = jdbcTemplate.query("select * from t_account", new BeanMapper());
            for (Account account : list) {
                System.out.println(account);
            }
        }
    }

    class BeanMapper implements RowMapper<Account>{
        public Account mapRow(ResultSet rs, int arg1) throws SQLException {
            Account account = new Account();
            account.setId(rs.getInt("id"));
            account.setName(rs.getString("name"));
            account.setMoney(rs.getDouble("money"));
            return account;
        }
    }

1. 步骤一：创建WEB工程，引入需要的jar包
    * IOC的6个包
    * AOP的4个包
    * C3P0的1个包
    * MySQL的驱动包
    * JDBC的2个包
    * 整合JUnit测试包

2. 步骤二：引入配置文件
    * 引入配置文件
        * 引入log4j.properties

        * 引入applicationContext.xml
            <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
                <property name="driverClass" value="com.mysql.jdbc.Driver"/>
                <property name="jdbcUrl" value="jdbc:mysql:///spring "/>
                <property name="user" value="root"/>
                <property name="password" value="root"/>
            </bean>

3. 步骤三：创建对应的包结构和类
    * com.kkb.demo1
        * AccountService
        * AccountServlceImpl
        * AccountDao
        * AccountDaoImpl

4. 步骤四:引入Spring的配置文件,将类配置到Spring中
    <bean id="accountService" class="com.kkb.demo1.AccountServiceImpl">
    </bean>

    <bean id="accountDao" class="com.kkb.demo1.AccountDaoImpl">
    </bean>

5. 步骤五：在业务层注入DAO ,在DAO中注入JDBC模板（强调：简化开发，以后DAO可以继承JdbcDaoSupport类）
    <bean id="accountService" class="com.kkb.demo1.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>

    <bean id="accountDao" class="com.kkb.demo1.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"/>
    </bean>

6. 步骤六：编写DAO和Service中的方法
    public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
        public void outMoney(String out, double money) {
            this.getJdbcTemplate().update("update t_account set money = money = ? where name = ?", money,out);
        }
        public void inMoney(String in, double money) {
            this.getJdbcTemplate().update("update t_account set money = money + ? where name = ?", money,in);
        }
    }

7. 步骤七：编写测试程序.
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class Demo1 {

        @Resource(name="accountService")
        private AccountService accountService;

        @Test
        public void run1(){
            accountService.pay("冠希", "美美", 1000);
        }
    }

1. 说明：Spring为了简化事务管理的代码:提供了模板类 TransactionTemplate，所以手动编程的方式来管理事务，只需要使用该模板类即可！！

2. 手动编程方式的具体步骤如下：
    1. 步骤一:配置一个事务管理器，Spring使用PlatformTransactionManager接口来管理事务，所以咱们需要使用到他的实现类！！
        <!-- 配置事务管理器 -->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"/>
        </bean>

    2. 步骤二:配置事务管理的模板
        <!-- 配置事务管理的模板 -->
        <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
            <property name="transactionManager" ref="transactionManager"/>
        </bean>

    3. 步骤三:在需要进行事务管理的类中,注入事务管理的模板
        <bean id="accountService" class="com.itheima.demo1.AccountServiceImpl">
            <property name="accountDao" ref="accountDao"/>
            <property name="transactionTemplate" ref="transactionTemplate"/>
        </bean>

    4. 步骤四:在业务层使用模板管理事务:
        // 注入事务模板对象
        private TransactionTemplate transactionTemplate;
        public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
            this.transactionTemplate = transactionTemplate;
        }

        public void pay(final String out, final String in, final double money) {
            transactionTemplate.execute(new TransactionCallbackWithoutResult() {

                protected void doInTransactionWithoutResult(TransactionStatus status) {
                    // 扣钱
                    accountDao.outMoney(out, money);
                    int a = 10/0;
                    // 加钱
                    accountDao.inMoney(in, money);
                }
            });
        }