<!-- 配置Service -->

    <bean id="acountService" class="com.sise.service.Impl.AcountServiceImpl">

        <!-- 注入dao-iAcounDao是ServiceImpl实现类中的IAcountDaoImpl属性来的，名称要一样 -->

        <property name="iAcounDao" ref="acountDao"></property>

    </bean>

    <!--配置Dao对象-->

    <bean id="acountDao" class="com.sise.dao.Impl.AcountDaoImpl">

        <!-- 注入QueryRunner -->

        <property name="runner" ref="runner"></property>

    </bean>



    <!--配置QueryRunner-->

    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">

        <!--注入数据源-->

        <constructor-arg name="ds" ref="dataSource"></constructor-arg>

<!--        <property name="runner" ref="runner"></property>  用这个就会出现错误-->

    </bean>

    <!-- 配置数据源 -->

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

        <!--连接数据库的必备信息-->

        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>

        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/item"></property>

        <property name="user" value="root"></property>

        <property name="password" value="8438031100"></property>

    </bean>

/**
 * 使用Junit单元测试：测试我们的配置
 */
@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration(classes = SrpingConfiguration.class)
@ContextConfiguration(locations="classpath:bean.xml")
public class AcountTest {
    @Autowired
    private IAcountService as;

    @Test
    public void testFindAll() {
        //3.执行方法
        //ClassPathXmlApplicationContext cac = new ClassPathXmlApplicationContext("bean.xml");
//        ApplicationContext cac = new AnnotationConfigApplicationContext(SrpingConfiguration.class);
//        IAcountService as = cac.getBean("acountService", IAcountService.class);
        List<AcountBean> all = as.findAll();
        for (AcountBean acountBean : all) {
            System.out.println(acountBean);
        }
    }

<!-- 告知spting往那些包及子包扫描注解信息 -->
    <bean:component-scan base-package="com.sise"></bean:component-scan>
    <!--配置QueryRunner-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!--注入数据源-->
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
<!--        <property name="runner" ref="runner"></property>  用这个就会出现错误-->
    </bean>
    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/item"></property>
        <property name="user" value="root"></property>
        <property name="password" value="8438031100"></property>
    </bean>

/*
* Configuration:说这个类是配置类
*
* 用于指定当前类是一个 spring 配置类，当创建容器时会从该类上加载注解
* 。获取容器时需要使用 AnnotationApplicationContext(有@Configuration 注解的类.class)。 属
* ComponentScan:告知spring扫描这个包下的所有文件注解
*
*     <!-- 告知spting往那些包及子包扫描注解信息 -->
    <bean:component-scan base-package="com.sise"></bean:component-scan>
    *
    * PropertySource:
    * 让这个文件加载再系统中，
    * @Value("${properties文件的 key}")
    *
    @Value("${jdbc.driver}")
    private String driver;
    *
    * Import加载非主配置文件，
* */
@Configuration
@ComponentScan("com.sise")
@Import(jdbcConfig.class)
@PropertySource("classpath:jdbcConfig.properties")
public class SrpingConfiguration {

}

//@Configuration
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;

    public jdbcConfig() {
    }

    /*
     * 作用：  该注解只能写在方法上，表明使用此方法创建一个对象，并且放入 spring 容器。
     * 属性：  name：给当前@Bean 注解方法创建的对象指定一个名称(即 bean 的 id）。
     * */
    @Bean(name = "runner")
    public QueryRunner createQueryRunner(DataSource dataSource) {
        QueryRunner runner = new QueryRunner(dataSource);
        return runner;
    }

    @Bean(name = "dataSource")
    public DataSource createDataSource() {
        ComboPooledDataSource pds = new ComboPooledDataSource();
        try {
            pds.setDriverClass(driver);
            pds.setJdbcUrl(url);
            pds.setUser(username);
            pds.setPassword(password);
            return pds;
        } catch (PropertyVetoException e) {
            throw new RuntimeException(e);
        }

    }

@Service(value = "acountService")
public class AcountServiceImpl implements IAcountService {

    @Autowired
    private IAcounDao iAcounDao;

  /*  public void setiAcounDao(AcountDaoImpl iAcounDao) {
        this.iAcounDao=iAcounDao;
    }用注解开发就不需要set办法
    */

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
//@ContextConfiguration(classes = SrpingConfiguration.class)
public class AcountTest {

    @Autowired
    @Qualifier("proxyAccountService")
    //因为proxyAccountService也是IAcountService的对象，而且还有一个acountService，就两个同一种对象类型

Autowired就无法自动注入就需要 @Qualifier("proxyAccountService")值得这个对象用IAcountService类型的哪个对象
    private IAcountService as;
    @Test
    public void testFindAll(){
        List<AcountBean> all = as.findAll();
        for (AcountBean acountBean : all) {
            System.out.println(acountBean);
        }
    }

    @Test
    public void testTinkHX(){
        as.findAcountByName("aaa","bbb",3000);
    }

<!-- 告知spting往那些包及子包扫描注解信息 -->
    <bean:component-scan base-package="com.sise"></bean:component-scan>

<!--    配置代理service-->
    <!--配置代理的service-->
    <bean id="proxyAccountService" factory-bean="beanfactory" factory-method="getAcountService"></bean>

动态代理第一种：

/**
         * 今天学习动态代理
         * 代理对象---producer
         * 字节码随用随创建，什么时候用什么时候加载
         * 作用：增强所需的办法，而且不改变代码（不改变办法）
         * 分类：基于子类的动态代理
         * 基于接口的动态代理
         * 如何创建代理对象
         * s使用----
         * Proxy.newProxyInstance(1，2，3)
         * 参数1：代理对象
         * ClassLoader
         * 想代理谁，就写谁的类加载器，写的是被代理的类加载器，
         * 也就是如果这个类（IProduce类，，想代理这个类，就写这个的类对象的类加载器）
         * 想代理谁就写谁
         * 固定写法：----------->类对象（IProducer producer）.getClass().getClassLoader()
         * 等价于-----producer.getClass().getClassLoader()
         *
         * 参数2：被代理对象
         *
         * interfaces:class[]
         *
         * 为了代理对象和被代理对象实现相同的办法时候，参数1，2的对象必须一致
         *固定写法：producer.getClass().getInterfaces()
         *
         * 参数3：
         * IncocationHandler:
         * 作用增强办法的内容
         * 或者说这个办法是如何让我们实现办法增强的逻辑办法，也就是想对这个办法增强必须再这里写，
         * 因为invoke(Object proxy, Method method, Object[] args)会拦截代理对象和被代理对象的所有办法（也就是拦截IProduce接口内的所有办法
         * 利用 if ("saleProduce".equals(method.getName())){}
         * 来判断是使用那个办法
         *
         * method.invoke(producer, money*0.8f);这个是执行办法--->代理对象，
         * 第二个就是参数这个saleProduce办法有多少个参数就写多少个）
         * ）
         * 返回值强转为接口类型
         */

        /*
         * producer.getClass()类对象.getClass()得到的是这个类的字节码----》等价于--->IProducer类.class
         * */

        IProducer proxyProduce = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(), producer.getClass().getInterfaces(), new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Float money = (Float) args[0];
                Object invoke = null;
                if ("saleProduce".equals(method.getName())) {
                    //invoke = method.invoke(producer, money * 0.8);//这个出错，因为吗，money是float，所以必须加f
                    invoke = method.invoke(producer, money * 0.8f);//这个是对的
                }
                return invoke;
            }
        });
        proxyProduce.saleProduce(10000);
    }

动态代理第二种：

final Producer producer=new Producer();

        /**
         * 今天学习动态代理
         * 代理对象---producer
         * 字节码随用随创建，什么时候用什么时候加载
         * 作用：增强所需的办法，而且不改变代码（不改变办法）
         * 分类：基于子类的动态代理
         * 基于接口的动态代理
         * 如何创建代理对象
         * s使用----
         * Proxy.newProxyInstance(1，2，3)
         * 参数1：代理对象字节码
         * Class
         * 想代理谁，就写谁的代理对象字节码
         * 也就是如果这个类（IProduce类，，想代理这个类，就写这个的类对象的字节码）
         * 想代理谁就写谁
         * 固定写法：----------->类对象（IProducer producer）.class
         *

         *
         * 参数2：
         * MethodInterceptor:
         * 作用增强办法的内容
         * 或者说这个办法是如何让我们实现办法增强的逻辑办法，也就是想对这个办法增强必须再这里写，
         * 因为Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
         *                 return null;
         *             }会拦截代理对象和被代理对象的所有办法（也就是拦截IProduce接口内的所有办法
         * 利用 if ("saleProduce".equals(method.getName())){}
         * 来判断是使用那个办法
         *
         * Object proxy:代理对象
         * Method method:代理办法
         * Object[] args:办法所需要的参数
         * MethodProxy methodProxy:当前执行办法的对象
         * method.invoke(producer, money*0.8f);这个是执行办法--->代理对象，
         * 第二个就是参数这个saleProduce办法有多少个参数就写多少个）
         * ）
         * 返回值强转为接口类型
         */

        /*
         * producer.getClass()类对象.getClass()得到的是这个类的字节码----》等价于--->IProducer类.class
         * */
        Producer proxyProduce= (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                Float money = (Float) args[0];
                Object invoke = null;
                if ("saleProduce".equals(method.getName())) {
                    //invoke = method.invoke(producer, money * 0.8);//这个出错，因为吗，money是float，所以必须加f
                    invoke = method.invoke(producer, money * 0.8f);//这个是对的
                }
                return invoke;
            }
        });
        proxyProduce.saleProduce(10000);