Spring相关知识

Spring
Spring框架
1.1.1 Spring的概述:
1.1.1.1 什么是Spring :

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

EE开发分成三层结构:

• WEB层:Spring MVC.
• 业务层:Bean管理:(IOC)
• 持久层:Spring的JDBC模板.ORM模板用于整合其他的持久层框架.

Expert One-to-One J2EE Design and Development :J2EE的设计和开发:(2002.EJB)
Expert One-to-One J2EE Development without EJB :J2EE不使用EJB的开发.
1.1.1.2 为什么学习Spring:
方便解耦，简化开发
Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理
AOP编程的支持
Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
声明式事务的支持
只需要通过配置就可以完成对事务的管理，而无需手动编程
方便程序的测试
Spring对Junit4支持，可以通过注解方便的测试Spring程序
方便集成各种优秀框架
Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持
降低JavaEE API的使用难度
Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低
1.1.1.3 Spring的版本:
Spring 3.X 和 Spring4.X
1.1.2 Spring的入门案例:(IOC)
1.1.2.1 IOC的底层实现原理

IOC：Inversion of Control 控制反转. 指的是 对象的创建权反转(交给)给Spring.spring管理对象的创建过程。
作用是实现了程序的解耦合.
1.1.2.2 步骤一:下载Spring的开发包:
官网：http://spring.io/
下载地址：http://repo.springsource.org/libs-release-local/org/springframework/spring解压:(Spring目录结构:)

• docs :API和开发规范.
• libs :jar包和源码.
• schema :约束.
  1.1.2.3 步骤二:创建web项目,引入Spring的开发包:

1.1.2.4 步骤三:引入相关配置文件:
log4j.properties
applicationContext.xml
引入约束:
spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html

1.1.2.5 步骤四:编写相关的类: public interface UserDao {

public void sayHello();

}

public class UserDaoImpl implements UserDao {

@Override
public void sayHello() {
	System.out.println("Hello Spring...");
}

}
1.1.2.6 步骤五:完成配置：

1.1.2.7 步骤六:编写测试程序:
@Test
// Spring的方式：
public void demo2(){
// 创建Spring的工厂类：
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(“applicationContext.xml”);
// 通过工厂解析XML获取Bean的实例.
UserDao userDao = (UserDao) applicationContext.getBean(“userDao”);
userDao.sayHello();
}
1.1.2.8 IOC和DI:
IOC :控制反转,将对象的创建权交给了Spring.
DI :Dependency Injection 依赖注入.需要有IOC创建对象的环境,Spring创建这个类的过程中,Spring将类的依赖的属性值（基本类型和对象类型）设置进去.

1.1.3 Spring中的工厂:
1.1.3.1 ApplicationContext:
ApplicatioContext接口有两个实现类:

ClassPathXmlApplicationContext :加载类路径下Spring的配置文件.
FileSystemXmlApplicationContext :加载本地磁盘下Spring的配置文件.
1.1.3.2 BeanFactory:

1.1.3.3 BeanFactory和ApplicationContext的区别:
BeanFactory :是在getBean的时候才会生成类的实例.
ApplicationContext :在加载applicationContext.xml时候就会创建.
1.1.4 配置STS的XML的提示:
1.1.4.1 Spring配置文件中提示的配置
复制路径:

• http://www.springframework.org/schema/beans/spring-beans.xsd
  查找XML Catalog:

点击Add…

1.1.5 Spring的相关配置:
1.1.5.1 id属性和name属性标签的配置
id :Bean起个名字. 在约束中采用ID的约束:唯一. 必须以字母开始，可以使用字母、数字、连字符、下划线、句话、冒号 id:不能出现特殊字符.

name:Bean起个名字. 没有采用ID的约束. name:出现特殊字符.如果没有id的话 , name可以当做id使用.

• 整合struts1的时候:
  

1.1.5.2 scope属性：Bean的作用范围.

• singleton :默认值，单例的.
• prototype :多例的.
• request :WEB项目中,Spring创建一个Bean的对象,将对象存入到request域中.
• session :WEB项目中,Spring创建一个Bean的对象,将对象存入到session域中.
• globalSession :WEB项目中,应用在Porlet环境.如果没有Porlet环境那么globalSession相当于session.

1.1.5.3 Bean的生命周期的配置:
通过配置标签上的init-method作为Bean的初始化的时候执行的方法，配置destroy-method作为Bean的销毁的时候执行的方法。
销毁方法想要执行，需要是单例创建的Bean而且在工厂关闭的时候，Bean才会被销毁.
1.1.6 Spring的Bean的管理XML的方式：
1.1.6.1 Spring的Bean的属性注入:
【构造方法的方式注入属性】

【set方法的方式注入属性】





1.1.6.2 Spring的属性注入：对象类型的注入:

1.1.6.3 名称空间p的属性注入的方式:Spring2.x版本后提供的方式.
第一步:引入p名称空间

第二步:使用p名称空间.
* 普通属性: p:属性名称=””
* 对象类型属性: p:属性名称-ref=””

<bean id="car2" class="cn.itcast.spring.demo4.Car2" p:name="宝马7" p:price="1200000"/>

1.1.6.4 SpEL的方式的属性注入:Spring3.x版本后提供的方式. SpEL：Spring Expression Language. 语法:#{ SpEL }

<!-- SpEL的注入的方式 -->
<bean id="car2" class="cn.itcast.spring.demo4.Car2">
	<property name="name" value="#{'奔驰'}"/>
	<property name="price" value="#{800000}"/>
</bean>

<bean id="person" class="cn.itcast.spring.demo4.Person">
	<property name="name" value="#{'冠希'}"/>
	<property name="car2" value="#{car2}"/>
</bean>

<bean id="carInfo" class="cn.itcast.spring.demo4.CarInfo"></bean>

引用了另一个类的属性
<bean id="car2" class="cn.itcast.spring.demo4.Car2">

	<property name="name" value="#{carInfo.carName}"/>
	<property name="price" value="#{carInfo.calculatePrice()}"/>
</bean>

1.1.6.5 注入复杂类型:

<bean id="collectionBean" class="cn.itcast.spring.demo5.CollectionBean">
	<!-- 数组类型的属性 -->
	<property name="arrs">
		<list>
			<value>会希</value>
			<value>冠希</value>
			<value>天一</value>
		</list>
	</property>
	
	<!-- 注入List集合的数据 -->
	<property name="list">
		<list>
			<value>芙蓉</value>
			<value>如花</value>
			<value>凤姐</value>
		</list>
	</property>
	
	<!-- 注入Map集合 -->
	<property name="map">
		<map>
			<entry key="aaa" value="111"/>
			<entry key="bbb" value="222"/>
			<entry key="ccc" value="333"/>
		</map>
	</property>
	
	<!-- Properties的注入 -->
	<property name="properties">
		<props>
			<prop key="username">root</prop>
			<prop key="password">123</prop>
		</props>
	</property>
</bean>

1.1.6.6 Spring的分配置文件的开发
一种:创建工厂的时候加载多个配置文件:
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(“applicationContext.xml”,“applicationContext2.xml”);

二种:在一个配置文件中包含另一个配置文件：

1.1.7 Spring的Bean管理:(注解方式)
1.1.7.1 步骤一:下载Spring的开发包:
官网：http://spring.io/
下载地址：http://repo.springsource.org/libs-release-local/org/springframework/spring解压:(Spring目录结构:)

• docs :API和开发规范.
• libs :jar包和源码.
• schema :约束.
  1.1.7.2 步骤二:创建web项目,引入Spring的开发包:

在Spring的注解的AOP中需要引入spring-aop的jar包。
1.1.7.3 步骤三:引入相关配置文件:
log4j.properties
applicationContext.xml
引入约束:
spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html

• 引入约束:(引入context的约束):
  

1.1.7.4 步骤四:编写相关的类: public interface UserDao {

public void sayHello();

}

public class UserDaoImpl implements UserDao {

@Override
public void sayHello() {
	System.out.println("Hello Spring...");
}

}
1.1.7.5 步骤五:配置注解扫描

<context:component-scan base-package="com.itheima.spring.demo1"/>

1.1.7.6 在相关的类上添加注解:
@Component(value=“userDao”)
public class UserDaoImpl implements UserDao {

@Override
public void sayHello() {
	System.out.println("Hello Spring Annotation...");
}

}
1.1.7.7 编写测试类:
@Test
public void demo2() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
“applicationContext.xml”);
UserDao userDao = (UserDao) applicationContext.getBean(“userDao”);
userDao.sayHello();
}

1.1.8 Spring的Bean管理的中常用的注解:
1.1.8.1 @Component:组件.(作用在类上)
Spring中提供@Component的三个衍生注解:(功能目前来讲是一致的)

• @Controller :WEB层
• @Service :业务层
• @Repository :持久层

这三个注解是为了让标注类本身的用途清晰，Spring在后续版本会对其增强
1.1.8.2 属性注入的注解:(使用注解注入的方式,可以不用提供set方法.)
@Value :用于注入普通类型.
@Autowired :自动装配:

• 默认按类型进行装配.
• 按名称注入:
• @Qualifier:强制使用名称注入.
  @Resource相当于:
• @Autowired和@Qualifier一起使用.
  1.1.8.3 Bean的作用范围的注解:
  @Scope:
• singleton:单例
• prototype:多例
  1.1.8.4 Bean的生命周期的配置:
  @PostConstruct :相当于init-method
  @PreDestroy :相当于destroy-method
  1.1.9 Spring的Bean管理的方式的比较:

XML和注解:

• XML :结构清晰.
• 注解 :开发方便.(属性注入.)

实际开发中还有一种XML和注解整合开发:

• Bean有XML配置.但是使用的属性使用注解注入

Xml的属性注入必须要依赖set方法，而用注解的方式可以不依赖set方法。.

1.1.10 AOP的概述
1.1.10.1 什么是AOP

Spring是解决实际开发中的一些问题:

• AOP解决OOP中遇到的一些问题.是OOP的延续和扩展.
  1.1.10.2 为什么学习AOP
  对程序进行增强:不修改源码的情况下.
• AOP可以进行权限校验,日志记录,性能监控,事务控制.
  1.1.10.3 Spring的AOP的由来:
  AOP最早由AOP联盟的组织提出的,制定了一套规范.Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范.
  1.1.10.4 底层实现:
  代理机制:
• Spring的AOP的底层用到两种代理机制：
  • JDK的动态代理 :针对实现了接口的类产生代理.针对带有接口的实现类，底层动态代理产生的是jdk的动态代理类
  • Cglib的动态代理 :针对没有实现接口的类产生代理. 应用的是底层的字节码增强的技术 生成当前类的子类对象.

1.1.11 Spring底层AOP的实现原理:（了解）
1.1.11.1 JDK动态代理增强一个类中方法:
public class MyJDKProxy implements InvocationHandler {

private UserDao userDao;

public MyJDKProxy(UserDao userDao) {
	this.userDao = userDao;
}

// 编写工具方法：生成代理：
public UserDao createProxy(){
	UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(),
			userDao.getClass().getInterfaces(), this);

	return userDaoProxy;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	if("save".equals(method.getName())){
		System.out.println("权限校验================");
	}
	return method.invoke(userDao, args);
}

}
1.1.11.2 Cglib动态代理增强一个类中的方法:
public class MyCglibProxy implements MethodInterceptor{

private CustomerDao customerDao;

public MyCglibProxy(CustomerDao customerDao){
	this.customerDao = customerDao;
}
// 生成代理的方法:
public CustomerDao createProxy(){
	// 创建Cglib的核心类:
	Enhancer enhancer = new Enhancer();
	// 设置父类:
	enhancer.setSuperclass(CustomerDao.class);
	// 设置回调:
	enhancer.setCallback(this);
	// 生成代理：
	CustomerDao customerDaoProxy = (CustomerDao) enhancer.create();
	return customerDaoProxy;
}
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
	if("delete".equals(method.getName())){
		Object obj = methodProxy.invokeSuper(proxy, args);
		System.out.println("日志记录================");
		return obj;
	}
	
	return methodProxy.invokeSuper(proxy, args);
}

}
1.1.12 Spring的基于AspectJ的AOP开发
1.1.12.1 AOP的开发中的相关术语:
Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.就是可以进行通知增强的那些方法。
Pointcut(切入点):所谓切入点是指我们要对那些Joinpoint进行增强的方法，是真正增强的方法。
Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)，就是一个方法，可以切入到其他类的方法前后上。
Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.
Target(目标对象):代理的目标对象，就是需要增强的那些切入点方法的类。
Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程.就是通知增强加入到切入点前后的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装在期织入
Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类
Aspect(切面): 里面主要是方法，在通知这个方法上配置在哪个切入点进行使用，
是由多个通知和多个切入点组成的。
1.1.13 Spring使用AspectJ进行AOP的开发：XML的方式（*****）
1.1.13.1 引入相应的jar包

• spring的传统AOP的开发的包
  spring-aop-4.2.4.RELEASE.jar
  com.springsource.org.aopalliance-1.0.0.jar
• aspectJ的开发包:
  com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
  spring-aspects-4.2.4.RELEASE.jar

1.1.13.2 引入Spring的配置文件
引入AOP约束:

1.1.13.3 编写目标类 创建接口和类: public interface OrderDao { public void save(); public void update(); public void delete(); public void find(); }

public class OrderDaoImpl implements OrderDao {

@Override
public void save() {
	System.out.println("保存订单...");
}

@Override
public void update() {
	System.out.println("修改订单...");
}
@Override
public void delete() {
	System.out.println("删除订单...");
}
@Override
public void find() {
	System.out.println("查询订单...");
}

}
1.1.13.4 目标类的配置



1.1.13.5 整合Junit单元测试
就是为了减少每次都要用工厂创建对象的过程，直接用注解的方式，然后把直接这个对象当做测试类的属性进行使用(前提要创建的对象必须已经在配置文件中进行ioc，把创建对象的权利交给了Spring)
引入spring-test.jar

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(“classpath:applicationContext.xml”)
public class SpringDemo3 {
@Resource(name=“orderDao”)
private OrderDao orderDao;

@Test
public void demo1(){
	orderDao.save();
	orderDao.update();
	orderDao.delete();
	orderDao.find();
}

}
1.1.13.6 通知类型
前置通知 ：在目标方法执行之前执行.
后置通知 ：在目标方法执行之后执行
环绕通知 ：在目标方法执行前和执行后执行
异常抛出通知：在目标方法执行出现 异常的时候 执行
最终通知 ：无论目标方法是否出现异常 最终通知都会 执行.
1.1.13.7 切入点表达式
execution(表达式)：就是用来简化表示切入点的表达式，可以更好的对切入点进行表达使用
表达式:
[方法访问修饰符] 方法返回值 包名.类名.方法名(方法的参数)
public * cn.itcast.spring.dao..(…)

• cn.itcast.spring.dao..(…)
• cn.itcast.spring.dao.UserDao+.*(…)
• cn.itcast.spring.dao….(…)

1.1.13.8 编写一个切面类
public class MyAspectXml {
// 前置增强
public void before(){
System.out.println(“前置增强===========”);
}
}
1.1.13.9 配置完成增强

<!-- 进行aop的配置 -->
<aop:config>
	<!-- 配置切入点表达式:哪些类的哪些方法需要进行增强 -->
	<aop:pointcut expression="execution(* cn.itcast.spring.demo3.OrderDao.save(..))" id="pointcut1"/>
	<!—切面：配置通知，就是在哪些切入点加入什么增强方法 -->
	<aop:aspect ref="myAspectXml">
		<aop:before method="before" pointcut-ref="pointcut1"/>
	</aop:aspect>
</aop:config>

1.1.13.10 其他的增强的配置：

<!-- 进行aop的配置 -->
<aop:config>
	<!-- 配置切入点表达式:哪些类的哪些方法需要进行增强 -->
	<aop:pointcut expression="execution(* cn.itcast.spring.demo3.*Dao.save(..))" id="pointcut1"/>
	<aop:pointcut expression="execution(* cn.itcast.spring.demo3.*Dao.delete(..))" id="pointcut2"/>
	<aop:pointcut expression="execution(* cn.itcast.spring.demo3.*Dao.update(..))" id="pointcut3"/>
	<aop:pointcut expression="execution(* cn.itcast.spring.demo3.*Dao.find(..))" id="pointcut4"/>
	<!-- 配置切面 -->
	<aop:aspect ref="myAspectXml">
		<aop:before method="before" pointcut-ref="pointcut1"/>
		<aop:after-returning method="afterReturing" pointcut-ref="pointcut2"/>
		<aop:around method="around" pointcut-ref="pointcut3"/>
		<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4"/>
		<aop:after method="after" pointcut-ref="pointcut4"/>
	</aop:aspect>
</aop:config>

1.1.14 Spring使用AspectJ进行AOP的开发:注解的方式
1.1.14.1 引入相关的jar包:

• spring的传统AOP的开发的包
  spring-aop-4.2.4.RELEASE.jar
  com.springsource.org.aopalliance-1.0.0.jar
• aspectJ的开发包:
  com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
  spring-aspects-4.2.4.RELEASE.jar

1.1.14.2 引入Spring的配置文件
引入AOP约束:

1.1.14.3 编写目标类: public class ProductDao { public void save(){ System.out.println("保存商品..."); } public void update(){ System.out.println("修改商品..."); } public void delete(){ System.out.println("删除商品..."); } public void find(){ System.out.println("查询商品..."); } } 1.1.14.4 配置目标类： 1.1.14.5 开启aop注解的自动代理: 1.1.14.6 AspectJ的AOP的注解: @Aspect:定义切面类的注解

通知类型:
* @Before :前置通知
* @AfterReturing :后置通知
* @Around :环绕通知
* @After :最终通知
* @AfterThrowing :异常抛出通知.

@Pointcut:定义切入点的注解
1.1.14.7 编写切面类:
@Aspect
public class MyAspectAnno {

@Before("MyAspectAnno.pointcut1()")
public void before(){
	System.out.println("前置通知===========");
}

@Pointcut("execution(* cn.itcast.spring.demo4.ProductDao.save(..))")
private void pointcut1(){}

}
1.1.14.8 配置切面:


1.1.14.9 其他通知的注解:
@Aspect
public class MyAspectAnno {

@Before("MyAspectAnno.pointcut1()")
public void before(){
	System.out.println("前置通知===========");
}

@AfterReturning("MyAspectAnno.pointcut2()")
public void afterReturning(){
	System.out.println("后置通知===========");
}

@Around("MyAspectAnno.pointcut3()")

//环绕通知的话必须传入这个链接点参数
public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
//在切入点前进行操作
System.out.println(“环绕前通知==========”);
//这个代表执行切入点这个方法
Object obj = joinPoint.proceed();
//在切入后前进行操作
System.out.println(“环绕后通知==========”);
return obj;
}
@AfterThrowing(“MyAspectAnno.pointcut4()”)
public void afterThrowing(){
System.out.println(“异常抛出通知========”);
}
@After(“MyAspectAnno.pointcut4()”)
public void after(){
System.out.println(“最终通知==========”);
}

//配置切入点，就是指明那个那个类里面的那个方法是切入点，方便使用，直接用
切面类.切面的方法名就可以代表那个切入点了。
@Pointcut(“execution(* cn.itcast.spring.demo4.ProductDao.save(…))”)
private void pointcut1(){}
@Pointcut(“execution(* cn.itcast.spring.demo4.ProductDao.update(…))”)
private void pointcut2(){}
@Pointcut(“execution(* cn.itcast.spring.demo4.ProductDao.delete(…))”)
private void pointcut3(){}
@Pointcut(“execution(* cn.itcast.spring.demo4.ProductDao.find(…))”)
private void pointcut4(){}
}
1.1.15 Spring的JDBC的模板:
1.1.15.1 Spring提供了很多持久层技术的模板类简化编程:

1.1.15.2 创建数据库和表:

1.1.15.3 引入相关开发包:
Spring的基本的开发包需要引入的:6个.

1.1.15.4 创建一个测试类:
@Test
// JDBC模板的基本使用：
public void demo1(){
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName(“com.mysql.jdbc.Driver”);
dataSource.setUrl(“jdbc:mysql:///spring_day03”);
dataSource.setUsername(“root”);
dataSource.setPassword(“123”);

	JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
	jdbcTemplate.update("insert into account values (null,?,?)", "会希",10000d);
}

1.1.16 将连接池的配置交给Spring管理:
1.1.16.1 Spring内置的连接池的配置：
【引入Spring的配置文件】

【配置内置连接池】







【将模板配置到Spring中】




【编写测试类】
**** 引入spring-aop.jar

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(“classpath:applicationContext.xml”)
public class SpringDemo2 {

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

@Test
public void demo1(){
	jdbcTemplate.update("insert into account values (null,?,?)", "凤姐",10000d);
}

}
1.1.16.2 Spring中配置DBCP连接池:
【引入dbcp连接池的jar包】

【配置连接池】







1.1.16.3 配置c3p0连接池:
【引入相应的jar包】
com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar

【配置连接池】







1.1.17 JDBC模板的CRUD的操作：
1.1.17.1 JDBC模板CRUD的操作:
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(“classpath:applicationContext.xml”)
public class SpringDemo3 {

@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 MyRowMapper(), 1);
	System.out.println(account);
}

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

class MyRowMapper implements RowMapper<Account>{

	@Override
	public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
		Account account = new Account();
		account.setId(rs.getInt("id"));
		account.setName(rs.getString("name"));
		account.setMoney(rs.getDouble("money"));
		return account;
	}
	
}

}

1.2 Spring的事务管理
1.2.1 事务的回顾
1.2.1.1 什么事务
 事务：逻辑上的一组操作，组成这组操作的各个单元，要么全都成功，要么全都失败。
1.2.1.2 事务的特性
 原子性：事务不可分割
 一致性：事务执行前后数据完整性保持一致
 隔离性：一个事务的执行不应该受到其他事务的干扰
 持久性：一旦事务结束，数据就持久化到数据库
1.2.1.3 如果不考虑隔离性引发安全性问题
 读问题
 脏读 ：一个事务读到另一个事务未提交的数据
 不可重复读 ：一个事务读到另一个事务已经提交的update的数据，导致一个事务中多次查询结果不一致
 虚读、幻读 ：一个事务读到另一个事务已经提交的insert的数据，导致一个事务中多次查询结果不一致。
 写问题
 丢失更新
1.2.1.4 解决读问题
 设置事务的隔离级别
 Read uncommitted ：未提交读，任何读问题解决不了。
 Read committed ：已提交读，解决脏读，但是不可重复读和虚读有可能发生。
 Repeatable read ：重复读，解决脏读和不可重复读，但是虚读有可能发生。
 Serializable ：解决所有读问题。
1.2.2 Spring的事务管理的API
1.2.2.1 PlatformTransactionManager：平台事务管理器
 平台事务管理器：接口，是Spring用于管理事务的真正的对象。
 DataSourceTransactionManager ：底层使用JDBC管理事务
 HibernateTransactionManager ：底层使用Hibernate管理事务
1.2.2.2 TransactionDefinition ：事务定义信息
 事务定义：用于定义事务的相关的信息，隔离级别、超时信息、传播行为、是否只读
1.2.2.3 TransactionStatus：事务的状态
 事务状态：用于记录在事务管理过程中，事务的状态的对象。
1.2.2.4 事务管理的API的关系：
Spring进行事务管理的时候，首先平台事务管理器根据事务定义信息进行事务的管理，在事务管理过程中，产生各种状态，将这些状态的信息记录到事务状态的对象中。
1.2.3 Spring的事务的传播行为
1.2.3.1 Spring的传播行为
 Spring中提供了七种事务的传播行为：
 保证多个操作在同一个事务中
 PROPAGATION_REQUIRED ：默认值，如果A中有事务，使用A中的事务，如果A没有，创建一个新的事务，将操作包含进来
 PROPAGATION_SUPPORTS ：支持事务，如果A中有事务，使用A中的事务。如果A没有事务，不使用事务。
 PROPAGATION_MANDATORY ：如果A中有事务，使用A中的事务。如果A没有事务，抛出异常。

 保证多个操作不在同一个事务中
 PROPAGATION_REQUIRES_NEW ：如果A中有事务，将A的事务挂起（暂停），创建新事务，只包含自身操作。如果A中没有事务，创建一个新事务，包含自身操作。
 PROPAGATION_NOT_SUPPORTED ：如果A中有事务，将A的事务挂起。不使用事务管理。
 PROPAGATION_NEVER ：如果A中有事务，报异常。

 嵌套式事务
 PROPAGATION_NESTED ：嵌套事务，如果A中有事务，按照A的事务执行，执行完成后，设置一个保存点，执行B中的操作，如果没有异常，执行通过，如果有异常，可以选择回滚到最初始位置，也可以回滚到保存点。
1.2.4 Spring的事务管理
1.2.4.1 搭建Spring的事务管理的环境
 创建Service的接口和实现类

 创建DAO的接口和实现类

 配置Service和DAO：交给Spring管理

 在DAO中编写扣钱和加钱方法：
 配置连接池和JDBC的模板

 在DAO注入Jdbc的模板：

 测试

1.2.5 Spring的事务管理：一类：编程式事务（需要手动编写代码）–了解
1.2.5.1 第一步：配置平台事务管理器

1.2.5.2 第二步：Spring提供了事务管理的模板类
 配置事务的管理的模板类

1.2.5.3 第三步：在业务层注入事务管理的模板

1.2.5.4 编写事务管理的代码

1.2.5.5 测试：

1.2.6 Spring的事务管理：二类：声明式事务管理（通过配置实现）—AOP
1.2.6.1 XML方式的声明式事务管理
 第一步：引入aop的开发包
 第二步：恢复转账环境
 第三步：配置事务管理器

 第四步：配置增强

 第五步：AOP的配置

 测试

1.2.6.2 注解方式的声明式事务管理
 第一步：引入aop的开发包
 第二步：恢复转账环境
 第三步：配置事务管理器

 第四步：开启注解事务

 第五步：在业务层添加注解