spring共四天
第一天：spring框架的概述以及spring中基于XML的IOC配置
第二天：spring中基于注解的IOC和ioc的案例
第三天：spring中的aop和基于XML以及注解的AOP配置
第四天：spring中的JdbcTemlate以及Spring事务控制
-----------------------------------------------------
1、spring的概述spring是什么spring的两大核心spring的发展历程和优势spring体系结构
2、程序的耦合及解耦曾经案例中问题工厂模式解耦
3、IOC概念和spring中的IOCspring中基于XML的IOC环境搭建
4、依赖注入（Dependency Injection）

package com.iteima.jdbc;import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;/*** 程序的耦合*      耦合：程序间的依赖关系*          包括：*              类之间的依赖*              方法间的依赖*      解耦：*          降低程序间的依赖关系*      实际开发中：*          应该做到：编译期不依赖，运行时才依赖*      解耦的思路：*          第一步：使用反射来创建对象，而避免使用new关键字*          第二步：通过读取配置文件来获取要创建的对象全限定类名*/
public class JdbcDemo1 {public static void main(String[] args) throws Exception {//1.注册驱动
//        DriverManager.registerDriver(new com.mysql.jdbc.Driver());Class.forName("com.mysql.jdbc.Driver");//2.获取连接Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/eesy", "root", "1234");//3.获取操作数据库的预处理对象PreparedStatement pstm = conn.prepareStatement("select * from account");//4.执行SQL，得到结果集ResultSet rs = pstm.executeQuery();//5.遍历结果集while(rs.next()) {System.out.println(rs.getString("name"));}//6.释放资源rs.close();pstm.close();conn.close();}
}

package com.itheima.dao;/*** 账户的持久层接口*/
public interface IAccountDao {/*** 模拟保存账户*/void saveAccount();
}

package com.itheima.dao.impl;import com.itheima.dao.IAccountDao;/*** 账户的持久层实现类*/
public class AccountDaoImpl implements IAccountDao {public void saveAccount() {System.out.println("保存了账户");}
}

package com.itheima.service;/*** 账户业务层的接口*/
public interface IAccountService {/*** 模拟保存账户*/void saveAccount();
}

package com.itheima.service.impl;import com.itheima.dao.IAccountDao;
import com.itheima.factory.BeanFactory;
import com.itheima.service.IAccountService;/*** 账户的业务层实现类*/
public class AccountServiceImpl implements IAccountService {//    private IAccountDao accountDao = new AccountDaoImpl();private IAccountDao accountDao = (IAccountDao)BeanFactory.getBean("accountDao");
//    private int i = 1;public void saveAccount() {int i = 1;accountDao.saveAccount();System.out.println(i);i++;}
}

package com.itheima.ui;import com.itheima.factory.BeanFactory;
import com.itheima.service.IAccountService;/*** 模拟一个表现层，用于调用业务层*/
public class Client {public static void main(String[] args) {//IAccountService as = new AccountServiceImpl();for(int i = 0; i < 5; i++) {IAccountService as = (IAccountService) BeanFactory.getBean("accountService");System.out.println(as);as.saveAccount();}}
}

package com.itheima.factory;import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;/*** 一个创建Bean对象的工厂* Bean：在计算机英语中，有可重用组件的含义* JavaBean：用java语言编写的可重用组件*      javabean > 实体类*   它就是创建我们的service和dao对象的*   第一个：需要一个配置文件来配置我们的service和dao*           配置的内容：唯一标识=全限定类名（key=value)*   第二个：通过读取配置文件中配置的内容，反射创建对象*   我的配置文件可以是xml也可以是properties*/
public class BeanFactory {//定义一个Properties对象private static Properties props;//定义一个Map，用于存放我们要创建的对象，我们把它称之为容器private static Map<String, Object> beans;//使用静态代码块为Properties对象赋值static {try {//实例化对象props = new Properties();//获取properties文件的流对象InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");props.load(in);//实例化容器beans = new HashMap<String, Object>();//取出配置文件中所有的KeyEnumeration keys = props.keys();//遍历枚举while (keys.hasMoreElements()) {//取出每个KeyString key = keys.nextElement().toString();//根据key获取valueString beanPath = props.getProperty(key);//反射创建对象Object value = Class.forName(beanPath).newInstance();//把key和value存入容器中beans.put(key, value);}} catch (Exception e) {throw new ExceptionInInitializerError("初始化properties失败！");}}/*** 根据bean的名称获取对象*/public static Object getBean(String beanName) {return beans.get(beanName);}/*** 根据Bean的名称获取bean对象public static Object getBean(String beanName) {Object bean = null;try {String beanPath = props.getProperty(beanName);
//            System.out.println(beanPath);bean = Class.forName(beanPath).newInstance();//每次都会调用默认构造函数创建对象} catch (Exception e) {e.printStackTrace();}return bean;}*/
}

accountService=com.itheima.service.impl.AccountServiceImpl
accountDao=com.itheima.dao.impl.AccountDaoImpl

package com.itheima.dao;/*** 账户的持久层接口*/
public interface IAccountDao {/*** 模拟保存账户*/void saveAccount();
}

package com.itheima.dao.impl;import com.itheima.dao.IAccountDao;/*** 账户的持久层实现类*/
public class AccountDaoImpl implements IAccountDao {public void saveAccount(){System.out.println("保存了账户");}
}

package com.itheima.service;/*** 账户业务层的接口*/
public interface IAccountService {/*** 模拟保存账户*/void saveAccount();
}

package com.itheima.service.impl;import com.itheima.dao.IAccountDao;
import com.itheima.service.IAccountService;/*** 账户的业务层实现类*/
public class AccountServiceImpl implements IAccountService {private IAccountDao accountDao ;public AccountServiceImpl(){System.out.println("对象创建了");}public void  saveAccount(){accountDao.saveAccount();}
}

package com.itheima.ui;import com.itheima.dao.IAccountDao;
import com.itheima.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;/*** 模拟一个表现层，用于调用业务层*/
public class Client {/*** 获取spring的Ioc核心容器，并根据id获取对象* ApplicationContext的三个常用实现类：*      ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下，不在的话，加载不了，（更常用）*      FileSystemXmlApplicationContext：它可以加载磁盘任意路径下的配置文件（必须有访问权限）*      AnnotationConfigApplicationContext：它是用于读取注解创建容器的，是明天的内容* 核心容器的两个接口引发出的问题：*  ApplicationContext:     单例对象适用              采用此接口*      它在构建核心容器时，创建对象采取的策略是采用立即加载的方式，也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象*  BeanFactory:            多例对象使用*      它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式，也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象*/public static void main(String[] args) {//1.获取核心容器对象ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//        ApplicationContext ac = new FileSystemXmlApplicationContext("C:UserszhyDesktopbean.xml");//2.根据id获取Bean对象IAccountService as  = (IAccountService)ac.getBean("accountService");IAccountDao adao = ac.getBean("accountDao",IAccountDao.class);System.out.println(as);System.out.println(adao);as.saveAccount();//--------BeanFactory----------
//        Resource resource = new ClassPathResource("bean.xml");
//        BeanFactory factory = new XmlBeanFactory(resource);
//        IAccountService as  = (IAccountService)factory.getBean("accountService");
//        System.out.println(as);}
}

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!--把对象的创建交给spring来管理--><bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean><bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"></bean>
</beans>

package com.itheima.service;/*** 账户业务层的接口*/
public interface IAccountService {/*** 模拟保存账户*/void saveAccount();
}

package com.itheima.service.impl;import com.itheima.service.IAccountService;/*** 账户的业务层实现类*/
public class AccountServiceImpl implements IAccountService {public AccountServiceImpl() {System.out.println("对象创建了");}public void saveAccount() {System.out.println("service中的saveAccount方法执行了。。。");}public void init() {System.out.println("对象初始化了。。。");}public void destroy() {System.out.println("对象销毁了。。。");}
}

package com.itheima.factory;import com.itheima.service.IAccountService;
import com.itheima.service.impl.AccountServiceImpl;/*** 模拟一个工厂类（该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数）*/
public class StaticFactory {public static IAccountService getAccountService() {return new AccountServiceImpl();}
}

package com.itheima.factory;import com.itheima.service.IAccountService;
import com.itheima.service.impl.AccountServiceImpl;/*** 模拟一个工厂类（该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数）*/
public class InstanceFactory {public IAccountService getAccountService() {return new AccountServiceImpl();}
}

package com.itheima.ui;import com.itheima.service.IAccountService;
import org.springframework.context.support.ClassPathXmlApplicationContext;/*** 模拟一个表现层，用于调用业务层*/
public class Client {public static void main(String[] args) {//1.获取核心容器对象
//        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");//2.根据id获取Bean对象IAccountService as = (IAccountService)ac.getBean("accountService");as.saveAccount();//手动关闭容器ac.close();}
}

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!--把对象的创建交给spring来管理--><!--spring对bean的管理细节1.创建bean的三种方式2.bean对象的作用范围3.bean对象的生命周期--><!--创建Bean的三种方式 --><!-- 第一种方式：使用默认构造函数创建。在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>--><!-- 第二种方式： 使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）<bean id="instanceFactory" class="com.itheima.factory.InstanceFactory"></bean><bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>--><!-- 第三种方式：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器)<bean id="accountService" class="com.itheima.factory.StaticFactory" factory-method="getAccountService"></bean>--><!-- bean的作用范围调整bean标签的scope属性：作用：用于指定bean的作用范围取值：常用的就是单例的和多例的singleton：单例的（默认值）prototype：多例的request：作用于web应用的请求范围session：作用于web应用的会话范围global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl" scope="prototype"></bean>--><!-- bean对象的生命周期单例对象出生：当容器创建时对象出生活着：只要容器还在，对象一直活着死亡：容器销毁，对象消亡总结：单例对象的生命周期和容器相同多例对象出生：当我们使用对象时spring框架为我们创建活着：对象只要是在使用过程中就一直活着。死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收--><bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"scope="prototype" init-method="init" destroy-method="destroy"></bean>
</beans>

package com.itheima.service.impl;import com.itheima.service.IAccountService;
import java.util.Date;/*** 账户的业务层实现类*/
public class AccountServiceImpl implements IAccountService {//如果是经常变化的数据，并不适用于注入的方式private String name;private Integer age;private Date birthday;public AccountServiceImpl(String name, Integer age, Date birthday) {this.name = name;this.age = age;this.birthday = birthday;}public void saveAccount() {System.out.println("service中的saveAccount方法执行了。。。" + name + "," + age + "," + birthday);}
}

package com.itheima.service.impl;import com.itheima.service.IAccountService;
import java.util.Date;/*** 账户的业务层实现类*/
public class AccountServiceImpl2 implements IAccountService {//如果是经常变化的数据，并不适用于注入的方式private String name;private Integer age;private Date birthday;public void setName(String name) {this.name = name;}public void setAge(Integer age) {this.age = age;}public void setBirthday(Date birthday) {this.birthday = birthday;}public void saveAccount() {System.out.println("service中的saveAccount方法执行了。。。" + name + "," + age + "," + birthday);}
}

package com.itheima.service.impl;import com.itheima.service.IAccountService;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import java.util.Map;/*** 账户的业务层实现类*/
public class AccountServiceImpl3 implements IAccountService {private String[] myStrs;private List<String> myList;private Set<String> mySet;private Map<String, String> myMap;private Properties myProps;public void setMyStrs(String[] myStrs) {this.myStrs = myStrs;}public void setMyList(List<String> myList) {this.myList = myList;}public void setMySet(Set<String> mySet) {this.mySet = mySet;}public void setMyMap(Map<String, String> myMap) {this.myMap = myMap;}public void setMyProps(Properties myProps) {this.myProps = myProps;}public void saveAccount(){System.out.println(Arrays.toString(myStrs));System.out.println(myList);System.out.println(mySet);System.out.println(myMap);System.out.println(myProps);}
}

package com.itheima.service;/*** 账户业务层的接口*/
public interface IAccountService {/*** 模拟保存账户*/void saveAccount();
}

package com.itheima.ui;import com.itheima.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;/*** 模拟一个表现层，用于调用业务层*/
public class Client {public static void main(String[] args) {//1.获取核心容器对象ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");//2.根据id获取Bean对象
//        IAccountService as = (IAccountService)ac.getBean("accountService");
//        as.saveAccount();
//        IAccountService as = (IAccountService)ac.getBean("accountService2");
//        as.saveAccount();IAccountService as = (IAccountService)ac.getBean("accountService3");as.saveAccount();}
}

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- spring中的依赖注入依赖注入：Dependency InjectionIOC的作用：降低程序间的耦合（依赖关系）依赖关系的管理：以后都交给spring来维护在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明依赖关系的维护：就称之为依赖注入依赖注入：能注入的数据：有三类基本类型和String其他bean类型（在配置文件中或者注解配置过的bean）复杂类型/集合类型注入的方式：有三种第一种：使用构造函数提供第二种：使用set方法提供第三种：使用注解提供（明天的内容）--><!--构造函数注入：使用的标签:constructor-arg标签出现的位置：bean标签的内部标签中的属性type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始name：用于指定给构造函数中指定名称的参数赋值                                        常用的=============以上三个用于指定给构造函数中哪个参数赋值===============================value：用于提供基本类型和String类型的数据ref：用于指定其他的bean类型数据，它指的就是在spring的Ioc核心容器中出现过的bean对象优势：在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功弊端：改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供--><bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"><constructor-arg name="name" value="泰斯特"></constructor-arg><constructor-arg name="age" value="18"></constructor-arg><constructor-arg name="birthday" ref="now"></constructor-arg></bean><!-- 配置一个日期对象 --><bean id="now" class="java.util.Date"></bean><!-- set方法注入                更常用的方式涉及的标签：property出现的位置：bean标签的内部标签的属性name：用于指定注入时所调用的set方法名称value：用于提供基本类型和String类型的数据ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象优势：创建对象时没有明确的限制，可以直接使用默认构造函数弊端：如果有某个成员必须有值，则获取对象是有可能set方法没有执行--><bean id="accountService2" class="com.itheima.service.impl.AccountServiceImpl2"><property name="name" value="TEST" ></property><property name="age" value="21"></property><property name="birthday" ref="now"></property></bean><!-- 复杂类型的注入/集合类型的注入用于给List结构集合注入的标签：list array set用于个Map结构集合注入的标签:map  props结构相同，标签可以互换--><bean id="accountService3" class="com.itheima.service.impl.AccountServiceImpl3"><property name="myStrs"><set><value>AAA</value><value>BBB</value><value>CCC</value></set></property><property name="myList"><array><value>AAA</value><value>BBB</value><value>CCC</value></array></property><property name="mySet"><list><value>AAA</value><value>BBB</value><value>CCC</value></list></property><property name="myMap"><props><prop key="testC">ccc</prop><prop key="testD">ddd</prop></props></property><property name="myProps"><map><entry key="testA" value="aaa"></entry><entry key="testB"><value>BBB</value></entry></map></property></bean>
</beans>

spring第二天：spring基于注解的IOC以及IoC的案例
1、spring中ioc的常用注解
2、案例使用xml方式和注解方式实现单表的CRUD操作持久层技术选择：dbutils
3、改造基于注解的ioc案例，使用纯注解的方式实现spring的一些新注解使用
4、spring和Junit整合

package com.itheima.dao;/*** 账户的持久层接口*/
public interface IAccountDao {/*** 模拟保存账户*/void saveAccount();
}

package com.itheima.dao.impl;import com.itheima.dao.IAccountDao;
import org.springframework.stereotype.Repository;/*** 账户的持久层实现类*/
@Repository("accountDao1")
public class AccountDaoImpl implements IAccountDao {public void saveAccount() {System.out.println("保存了账户1111111111111");}
}

package com.itheima.dao.impl;import com.itheima.dao.IAccountDao;
import org.springframework.stereotype.Repository;/*** 账户的持久层实现类*/
@Repository("accountDao2")
public class AccountDaoImpl2 implements IAccountDao {public void saveAccount() {System.out.println("保存了账户2222222222222");}
}

package com.itheima.service;/*** 账户业务层的接口*/
public interface IAccountService {/*** 模拟保存账户*/void saveAccount();
}

package com.itheima.service.impl;import com.itheima.dao.IAccountDao;
import com.itheima.service.IAccountService;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;/*** 账户的业务层实现类* 曾经XML的配置：*  <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"*        scope=""  init-method="" destroy-method="">*      <property name=""  value="" | ref=""></property>*  </bean>** 用于创建对象的*      他们的作用就和在XML配置文件中编写一个<bean>标签实现的功能是一样的*      Component:*          作用：用于把当前类对象存入spring容器中*          属性：*              value：用于指定bean的id，当我们不写时，它的默认值是当前类名，且首字母改小写*      Controller：一般用在表现层*      Service：一般用在业务层*      Repository：一般用在持久层*      以上三个注解他们的作用和属性与Component是一模一样*      他们三个是spring框架为我们提供明确的三层使用的注解，使我们的三层对象更加清晰** 用于注入数据的*      他们的作用就和在xml配置文件中的bean标签中写一个<property>标签的作用是一样的*      Autowired:*          作用：自动按照类型注入。只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功*                如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错*                如果Ioc容器中有多个类型匹配时：*          出现位置：*              可以是变量上，也可以是方法上*          细节：*              在使用注解注入时，set方法就不是必须的了*      Qualifier:*          作用：在按照类中注入的基础之上再按照名称注入，它在给类成员注入时不能单独使用。但是在给方法参数注入时可以（稍后我们讲）*          属性：*              value：用于指定注入bean的id*      Resource*          作用：直接按照bean的id注入，它可以独立使用*          属性：*              name：用于指定bean的id*      以上三个注入都只能注入其他bean类型的数据，而基本类型和String类型无法使用上述注解实现*      另外，集合类型的注入只能通过XML来实现**      Value*          作用：用于注入基本类型和String类型的数据*          属性：*              value：用于指定数据的值，它可以使用spring中SpEL(也就是spring的el表达式）*                      SpEL的写法：${表达式}** 用于改变作用范围的*      他们的作用就和在bean标签中使用scope属性实现的功能是一样的*      Scope*          作用：用于指定bean的作用范围*          属性：*              value：指定范围的取值，常用取值：singleton prototype** 和生命周期相关 了解*      他们的作用就和在bean标签中使用init-method和destroy-methode的作用是一样的*      PreDestroy*          作用：用于指定销毁方法*      PostConstruct*          作用：用于指定初始化方法*/
@Service("accountService")
//@Scope("prototype")
public class AccountServiceImpl implements IAccountService {//    @Autowired
//    @Qualifier("accountDao1")@Resource(name = "accountDao2")private IAccountDao accountDao = null;@PostConstructpublic void init() {System.out.println("初始化方法执行了");}@PreDestroypublic void destroy() {System.out.println("销毁方法执行了");}public void saveAccount() {accountDao.saveAccount();}
}

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><!--告知spring在创建容器时要扫描的包，配置所需要的标签不是在beans的约束中，而是一个名称为context名称空间和约束中--><context:component-scan base-package="com.itheima"></context:component-scan>
</beans>

package com.itheima.domain;import java.io.Serializable;/*** 账户的实体类*/
public class Account implements Serializable {private Integer id;private String name;private Float money;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 Float getMoney() {return money;}public void setMoney(Float money) {this.money = money;}@Overridepublic String toString() {return "Account{" +"id=" + id +", name='" + name + ''' +", money=" + money +'}';}
}

package com.itheima.dao;import com.itheima.domain.Account;
import java.util.List;/*** 账户的持久层接口*/
public interface IAccountDao {List<Account> findAllAccount();Account findAccountById(Integer accountId);void saveAccount(Account account);void updateAccount(Account account);void deleteAccount(Integer acccountId);
}

package com.itheima.dao.impl;import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import java.util.List;/*** 账户的持久层实现类*/
public class AccountDaoImpl implements IAccountDao {private QueryRunner runner;public void setRunner(QueryRunner runner) {this.runner = runner;}@Overridepublic List<Account> findAllAccount() {try{return runner.query("select * from account", new BeanListHandler<Account>(Account.class));}catch (Exception e) {throw new RuntimeException(e);}}@Overridepublic Account findAccountById(Integer accountId) {try{return runner.query("select * from account where id = ? ", new BeanHandler<Account>(Account.class),accountId);}catch (Exception e) {throw new RuntimeException(e);}}@Overridepublic void saveAccount(Account account) {try{runner.update("insert into account(name,money)values(?,?)", account.getName(), account.getMoney());}catch (Exception e) {throw new RuntimeException(e);}}@Overridepublic void updateAccount(Account account) {try{runner.update("update account set name=?,money=? where id=?", account.getName(), account.getMoney(), account.getId());}catch (Exception e) {throw new RuntimeException(e);}}@Overridepublic void deleteAccount(Integer accountId) {try{runner.update("delete from account where id=?", accountId);}catch (Exception e) {throw new RuntimeException(e);}}
}

package com.itheima.service;import com.itheima.domain.Account;
import java.util.List;/*** 账户的业务层接口*/
public interface IAccountService {List<Account> findAllAccount();Account findAccountById(Integer accountId);void saveAccount(Account account);void updateAccount(Account account);void deleteAccount(Integer acccountId);
}

package com.itheima.service.impl;import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import java.util.List;/*** 账户的业务层实现类*/
public class AccountServiceImpl implements IAccountService{private IAccountDao accountDao;public void setAccountDao(IAccountDao accountDao) {this.accountDao = accountDao;}@Overridepublic List<Account> findAllAccount() {return accountDao.findAllAccount();}@Overridepublic Account findAccountById(Integer accountId) {return accountDao.findAccountById(accountId);}@Overridepublic void saveAccount(Account account) {accountDao.saveAccount(account);}@Overridepublic void updateAccount(Account account) {accountDao.updateAccount(account);}@Overridepublic void deleteAccount(Integer acccountId) {accountDao.deleteAccount(acccountId);}
}

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 配置Service --><bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"><!-- 注入dao --><property name="accountDao" ref="accountDao"></property></bean><!--配置Dao对象--><bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"><!-- 注入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></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/eesy"></property><property name="user" value="root"></property><property name="password" value="1234"></property></bean>
</beans>

package com.itheima.test;import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;/*** 使用Junit单元测试：测试我们的配置*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {@Autowiredprivate IAccountService as;@Testpublic void testFindAll() {//3.执行方法List<Account> accounts = as.findAllAccount();for(Account account : accounts) {System.out.println(account);}}@Testpublic void testFindOne() {//3.执行方法Account account = as.findAccountById(1);System.out.println(account);}@Testpublic void testSave() {Account account = new Account();account.setName("test");account.setMoney(12345f);//3.执行方法as.saveAccount(account);}@Testpublic void testUpdate() {//3.执行方法Account account = as.findAccountById(4);account.setMoney(23456f);as.updateAccount(account);}@Testpublic void testDelete() {//3.执行方法as.deleteAccount(4);}
}

package com.itheima.domain;import java.io.Serializable;/*** 账户的实体类*/
public class Account implements Serializable {private Integer id;private String name;private Float money;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 Float getMoney() {return money;}public void setMoney(Float money) {this.money = money;}@Overridepublic String toString() {return "Account{" +"id=" + id +", name='" + name + ''' +", money=" + money +'}';}
}

package com.itheima.dao;import com.itheima.domain.Account;
import java.util.List;/*** 账户的持久层接口*/
public interface IAccountDao {List<Account> findAllAccount();Account findAccountById(Integer accountId);void saveAccount(Account account);void updateAccount(Account account);void deleteAccount(Integer acccountId);
}

package com.itheima.dao.impl;import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import java.util.List;/*** 账户的持久层实现类*/
@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {@Autowiredprivate QueryRunner runner;@Overridepublic List<Account> findAllAccount() {try{return runner.query("select * from account", new BeanListHandler<Account>(Account.class));}catch (Exception e) {throw new RuntimeException(e);}}@Overridepublic Account findAccountById(Integer accountId) {try{return runner.query("select * from account where id = ? ", new BeanHandler<Account>(Account.class), accountId);}catch (Exception e) {throw new RuntimeException(e);}}@Overridepublic void saveAccount(Account account) {try{runner.update("insert into account(name,money)values(?,?)", account.getName(), account.getMoney());}catch (Exception e) {throw new RuntimeException(e);}}@Overridepublic void updateAccount(Account account) {try{runner.update("update account set name=?,money=? where id=?", account.getName(), account.getMoney(), account.getId());}catch (Exception e) {throw new RuntimeException(e);}}@Overridepublic void deleteAccount(Integer accountId) {try{runner.update("delete from account where id=?", accountId);}catch (Exception e) {throw new RuntimeException(e);}}
}

package com.itheima.service;import com.itheima.domain.Account;
import java.util.List;/*** 账户的业务层接口*/
public interface IAccountService {List<Account> findAllAccount();Account findAccountById(Integer accountId);void saveAccount(Account account);void updateAccount(Account account);void deleteAccount(Integer acccountId);
}

package com.itheima.service.impl;import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;/*** 账户的业务层实现类*/
@Service("accountService")
public class AccountServiceImpl implements IAccountService {@Autowiredprivate IAccountDao accountDao;@Overridepublic List<Account> findAllAccount() {return accountDao.findAllAccount();}@Overridepublic Account findAccountById(Integer accountId) {return accountDao.findAccountById(accountId);}@Overridepublic void saveAccount(Account account) {accountDao.saveAccount(account);}@Overridepublic void updateAccount(Account account) {accountDao.updateAccount(account);}@Overridepublic void deleteAccount(Integer acccountId) {accountDao.deleteAccount(acccountId);}
}

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><!-- 告知spring在创建容器时要扫描的包 --><context:component-scan base-package="com.itheima"></context:component-scan><!--配置QueryRunner--><bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype"><!--注入数据源--><constructor-arg name="ds" ref="dataSource"></constructor-arg></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/eesy"></property><property name="user" value="root"></property><property name="password" value="1234"></property></bean>
</beans>

package com.itheima.test;import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;/*** 使用Junit单元测试：测试我们的配置*/
public class AccountServiceTest {@Testpublic void testFindAll() {//1.获取容器ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");//2.得到业务层对象IAccountService as = ac.getBean("accountService", IAccountService.class);//3.执行方法List<Account> accounts = as.findAllAccount();for(Account account : accounts){System.out.println(account);}}@Testpublic void testFindOne() {//1.获取容器ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");//2.得到业务层对象IAccountService as = ac.getBean("accountService", IAccountService.class);//3.执行方法Account account = as.findAccountById(1);System.out.println(account);}@Testpublic void testSave() {Account account = new Account();account.setName("test");account.setMoney(12345f);//1.获取容器ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");//2.得到业务层对象IAccountService as = ac.getBean("accountService", IAccountService.class);//3.执行方法as.saveAccount(account);}@Testpublic void testUpdate() {//1.获取容器ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");//2.得到业务层对象IAccountService as = ac.getBean("accountService", IAccountService.class);//3.执行方法Account account = as.findAccountById(4);account.setMoney(23456f);as.updateAccount(account);}@Testpublic void testDelete() {//1.获取容器ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");//2.得到业务层对象IAccountService as = ac.getBean("accountService", IAccountService.class);//3.执行方法as.deleteAccount(4);}
}