一、Spring作用
1.生态体系庞大，全能型选手！【springmvc是其一个子模块，jdbcTemplate能直接操作数据库！】
2.将其他组件粘合在一起
3.IOC容器和AOP[Aspect Oreinted Programming]:
Spring的Ioc[Inverse of Controller]机制（控制反转和依赖注入）正是用在此处。
Spring的Ioc（控制反转和依赖注入）
控制反转[Ioc]：就是由容器控制程序之间的（依赖）关系，而非传统实现中，由程序代码直接操控。
控制反转是一种思想，其具体实现就是依赖注入！
依赖注入[DI:Dependency Injection]：组件之间的依赖关系由容器在运行期决定，由容器动态的将某种依赖关系注入到组件之中。
二、搭建Spring IOC容器需要的开发环境
1.导入IOC容器需要的jar包
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELEASE.jar
spring-core-4.0.0.RELEASE.jar
spring-expression-4.0.0.RELEASE.jar
commons-logging-1.1.3.jar
2.创建Spring配置文件[Spring bean Configuration File]
applicationContext.xml
三、IOC容器创建对象步骤
1.创建IOC容器对象
private ApplicationContext ioc=new FileSystemXmlApplicationContext("C:\Users\Administrator\Desktop\applicationContext.xml"); //本地文件系统（磁盘）
* private ApplicationContext ioc1=new ClassPathXmlApplicationContext("applicationContext.xml"); //src下
2.使用IOC容器在创建对象的同时，给对象的属性赋值
从IOC容器中获取对象就两种方式：1、通过id值获取bean对象
2、通过IOC容器中bean的类型获取bean对象
<!--实验1：通过IOC容器创建对象，并为属性赋值 -->
<!-- 需要由IOC容器创建对象的全类名 -->
<!-- 为了便于从IOC容器中获取book对象，声明一个一个唯一的id值 -->
<bean id="book01" class="com.neuedu.spring.bean.Book">
<property name="bookId" value="2001"></property>
<property name="bookName" value="三国演义"></property>
<property name="author" value="罗贯中"></property>
<property name="price" value="22.5"></property>
</bean>
@Test public void test01() { //1.创建IOC容器自身的对象 //指定配置文件以类路径为基准的配置文件名 ApplicationContext ioc= new ClassPathXmlApplicationContext("bean.xml"); //2.从IOC容器中获取指定的对象 Object bean = ioc.getBean("book01"); System.out.println(bean); }
注意：
①IOC容器本身对象创建时，会将配置文件中配置好的bean先创建出来
②默认是单实例的，只创建bean的一个对象
③如果设置bean的scope属性为prototype，那么创建bean的对象就是多实例的，在获取的时候创建，每次获取对象都会创建新的
④.从IOC容器中获取对象
①根据bean的id获取
②根据bean的类型获取：要求容器中指定类型的bean是唯一的
bean的后置处理器：
1.指的是在bean的初始化方法前后执行操作的专门的对象。
2.自定义的后置处理器：
1)需要实现接口：org.springframework.beans.factory.config.BeanPostProcessor .
2) 做相应的配置就好！
<!-- bean的后置处理器 --> <bean id="beanPostProcessor" class="com.neuedu.entity.MyBeanPostProcessor"></bean>
package com.neuedu.entity; import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanPostProcessor; public class MyBeanPostProcessor implements BeanPostProcessor{ @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("==================================="); System.out.println("BeforeInitialization:"+beanName+"="+bean); return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println("============================="); System.out.println("AfterInitialization:"+beanName+"="+bean); return bean; } }
/*bean的后置处理器*/ @Test public void test02() { Object bean = ioc.getBean("beanPostProcessor"); System.out.println(bean); }
配置FactoryBean★
public class MyFactoryBean implements FactoryBean<Book> {
@Override
public Book getObject() throws Exception {
return new Book(22, "无字天书", "好啊", 22.5);
}
@Override
public Class<?> getObjectType() {
return Book.class;
}
@Override
public boolean isSingleton() {
return false;
}
}
测试bean的作用域，分别创建单实例和多实例的bean★
<!-- scope属性为prototype，那么创建bean的对象就是多实例的 -->
<bean id="user" class="com.neuedu.entity.User" scope="prototype">
<property name="id" value="user01"/>
<property name="name" value="Danny"/>
<property name="age" value="23"/>
</bean>
<!-- scope属性为singleton为默认值，默认是单实例的，只创建bean的一个对象 -->
<bean id="user" class="com.neuedu.entity.User" scope="singleton">
<property name="id" value="user01"/>
<property name="name" value="Danny"/>
<property name="age" value="23"/>
</bean>
实验22：创建带有生命周期方法的bean
<!--创建带有生命周期方法的bean --> <bean id="lifeObject" class="com.neuedu.entity.LifeObject" init-method="initMethod" destroy-method="destroyMethod" />
实验22[补充]：测试bean的后置处理器
①在bean的初始化方法调用前后执行操作的专门的对象
②自定义后置处理器实现该接口：org.springframework.beans.factory.config.BeanPostProcessor
③在springmvc中配置一下该bean对象.
<bean class="com.neuedu.spring.bean.Book" init-method="init"></bean>
<bean id="myBeanPostProcessor" class="com.neuedu.spring.bean.MyBeanPostProcessor"></bean>
批处理(batch)
- 批处理指的是一次操作中执行多条SQL语句
- 批处理相比于一次一次执行效率会提高很多
- 批处理主要是分两步：
1.将要执行的SQL语句保存
2.执行SQL语句
- Statement和PreparedStatement都支持批处理操作，这里我们只需要掌握PreparedStatement的批处理方式：
- 方法：
void addBatch()
- 将要执行的SQL先保存起来，先不执行
- 这个方法在设置完所有的占位符之后调用
int[] executeBatch()
- 这个方法用来执行SQL语句，这个方法会将批处理中所有SQL语句执行
- mysql默认批处理是关闭的，所以我们还需要去打开mysql的批处理：
? rewriteBatchedStatements=true
我们需要将以上的参数添加到mysql的url地址中
- 注意：低版本的mysql-jdbc驱动也不支持批处理
事务（Transaction）
- 在开发中我们的一个业务往往需要同时操作多个表，这些操作往往是不可分割，业务中的对数据库的多次操作,
要么同时成功，要么全都失败。
- 注意：我们在同一个事务中使用的数据库连接（Connection）必须是同一个。
- 事务的特性（ACID）：
原子性（atomicity）
一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。
一致性（consistency）
事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
隔离性（isolation）
一个事务的执行不能被其他事务干扰。
即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
持久性（durability）
持久性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久。 接下来的其他操作或故障不应该对其有任何影响。
- 操作失误的基本步骤：
1.开启事务
- 开启事务以后，我们只后的所有操作将都会在同一个事务当中
2.操作数据库
- 开启事务以后再去操作数据库，所有操作将不会直接提交到数据库中
3.提交事务
- 将修改应用到数据库
4.回滚事务
- 数据库操作过程中出现异常了，回滚事务，回滚事务以后，数据库变成开启事务之前的状态
- mysql中的事务控制
#开启事务
START TRANSACTION
#回滚事务
ROLLBACK
#提交事务
COMMIT
- JDBC中的事务主要通过Connection对象来控制的
1.开启事务
void setAutoCommit(boolean autoCommit) throws SQLException;
- 设置事务是否自动提交，默认是自动提交
- 设置事务手动提交
conn.setAutoCommit(false);
2.提交事务
void commit() throws SQLException;
- 提交事务
conn.commit()
3.回滚事务
void rollback() throws SQLException;
- 回滚事务
conn.rollback()
- 事务控制的格式：
//创建一个Connection
Connection conn = null;
try{
//获取Connection
conn = JDBCUtils.getConnection();
//开启事务
conn.setAutoCommit(false);
//对数据库进行操作
//操作成功，提交事务
conn.commit();
}catch(Exception e){
e.printStackTrace();
//回滚事务
try {
conn.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
}finally{
JDBCUtils.close(conn, null, null);
}
数据库连接池：
6) 数据库连接池
> 数据库连接池就是存放数据库连接（Connection）的集合
> 我们获取一个数据库连接是一个相对很麻烦的过程，
如果我们获取一个数据库连接，使用一次以后就给它关闭了
下一次再去使用的时候就要重新创建一个新的数据库连接。
> 所以我们提出了一个数据库连接池的概念，数据库连接池放的都是数据库连接（Connection）
我们在去使用数据库连接时候，不用再去重新创建数据库连接，而是直接从池中获取，
使用完的数据库连接，也不是直接销毁，而是要放回到连接池。
> 数据库连接池的常见的属性：
? 初始连接数量：数据连接池创建以后，保存数据库连接的数量
? 最小空闲连接数：数据库连接池最少得未使用的数据库连接的数量
最大空闲连接数：数据库连接池最大闲置连接数，当闲置连接数满了以后，将不会有其他连接进入池
? 每次增加连接数：当数据库连接都被占用以后，一次性增加的数据库连接的个数
? 最大连接数：数据库连接池的最大容量，当最大连接数饱和了，则不再创建新的数据库连接
? 最大等待时间：当数据库连接池饱和以后，等待获取数据库连接的时间
> 常见的数据库连接池
- 所有的数据库连接池都需要实现DataSource，当使用数据库连接池是，我们便不再需要使用DriverManger获取数据库连接
而是使用DataSource。
- Connection getConnection()
- 从数据库连接池中获取数据库连接对象
1.DBCP
- DBCP是Apache出品的一款数据库连接
- DBCP依赖于commons-pool
- 使用DBCP需要导入两个jar包：
commons-dbcp-1.4.jar
commons-pool-1.5.5.jar
- 当我们通过数据库连接池获取数据库连接以后，我们所获取到数据库连接已经不是我们熟悉的那个Connection
数据库连接池对Connection对象进行了包装，它修改Connection的close()方法，
再去调用close()数据库连接将不会真的关闭，而是要放回到数据库连接池中，供其他线程使用。
- 核心类：
BasicDataSourceFactory
2.C3P0（重点）
- C3P0使用的是XML作为配置文件
- 使用c3p0需要导入一个jar包：
c3p0-0.9.1.2.jar
- 导入c3p0的配置文件：
1.配置文件的名字：c3p0-cofig.xml
2.配置文件要求放到类路径下（src）
- 核心类：
ComboPooledDataSource
- 注意：
DataSource就相当于池子，我们的数据库连接都是从DataSource中获取的，
如果程序中有多个DataSource的实例，那么我们说你还不如不用数据库连接池。
所以我们的DataSource在项目中应该只有一个实例。
实验23：引用外部属性文件★
jdbc.properties文件：
jdbc.user=root
jdbc.passowrd=123456
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.driver=com.mysql.jdbc.Driver
<context:property-placeholder location="classpath:jdbc.properties"/>
1.在目标属性上加@Value注解
@Value("${jdbc.user}")
private String username;
2.
<!-- 根据外部属性文件中的信息配置数据源 -->
<bean id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="${jdbc.user}"></property>
<property name="password" value="${jdbc.passowrd}"></property>
<property name="jdbcUrl" value="${jdbc.url}"></property>
<property name="driverClass" value="${jdbc.driver}"></property>
</bean>
ComboPooledDataSource bean = ioc.getBean(ComboPooledDataSource.class);
Connection connection = bean.getConnection();
System.out.println(connection);
Statement st = connection.createStatement();
ResultSet rs = st.executeQuery("select * from stu");
while(rs.next()){
String string = rs.getString("name");
String string2 = rs.getString("school");
System.out.println(string+"==="+string2);
}
实验24：基于XML的属性装配
①手动装配
<!-- 属性的装配：手动装配 -->
<bean id="userService" class="com.neuedu.spring.bean.UserService"></bean>
<bean id="userAction" class="com.neuedu.spring.bean.UserAction">
<property name="userService" ref="userService"></property>
</bean>
②自动装配
<!-- 1.按类型装配：byType -->
<!-- 首先检测当前bean中需要装配的属性的类型 -->
<!-- 然后在IOC容器中查找匹配这个类型的bean -->
<!-- 如果类型匹配的bean是唯一的，那么就将这个匹配的bean注入到userAction中 -->
<bean id="userService" class="com.neuedu.spring.bean.UserService"></bean>
<bean id="userAction" autowire="byType" class="com.neuedu.spring.bean.UserAction"></bean>
<!-- 2.按bean的id值装配：byName -->
<!-- 首先检测当前bean中需要装配的属性的属性名，属性名是将setXxx()方法去掉set，首字母小写得到的 -->
<!-- 然后根据属性名作为id的值，在IOC容器中查找对应的bean -->
<!-- 如果能够找到，则将找到bean注入进去 -->
6。SpEL简介【见WORLD文档---了解】
Spring Expression Language，Spring表达式语言，简称SpEL。支持运行时查询并可以操作对象图。
和JSP页面上的EL表达式、Struts2中用到的OGNL表达式一样，SpEL根据JavaBean风格的getXxx()、setXxx()方法定义的属性访问对象图，完全符合我们熟悉的操作习惯。
6.1 基本语法
SpEL使用#{…}作为定界符，所有在大框号中的字符都将被认为是SpEL表达式。
6.2 使用字面量
●整数：<property name="count" value="#{5}"/>
●小数：<property name="frequency" value="#{89.7}"/>
●科学计数法：<property name="capacity" value="#{1e4}"/>
●String类型的字面量可以使用单引号或者双引号作为字符串的定界符号
<property name=“name” value="#{'Chuck'}"/>
<property name='name' value='#{"Chuck"}'/>
●Boolean：<property name="enabled" value="#{false}"/>
实验25：[SpEL测试I]在SpEL中使用字面量
实验26：[SpEL测试II]在SpEL中引用其他bean
实验27：[SpEL测试III]在SpEL中引用其他bean的某个属性值
实验28：[SpEL测试IV]在SpEL中调用非静态方法
实验29：[SpEL测试V]在SpEL中调用静态方法
实验30：[SpEL测试VI]在SpEL中使用运算符
8.使用注解配置bean
①声明bean的注解
@Component 将当前类声明为IOC容器中的一个普通的组件
@Controller 将当前类声明为IOC容器中的一个控制器组件
@Service 将当前类声明为IOC容器中的业务逻辑层组件
@Repository 将当前类声明为IOC容器中的一个持久化层组件
Spring根据上述注解其实并不能分辨当前类是否真的是一个控制器或Dao，即使标记的类和注解不对应也没有语法错误。但在实际工作中，肯定要将专门的注解标记在对应的类上面。
②使用基于注解的bean的配置，需要额外导入一个jar包：spring-aop-4.0.0.RELEASE.jar
③需要设置自动扫描的包
< context:component-scan base-package ="com.neuedu.ioc.bean"/>
④使用注解后，默认按照类名首字母小写作为id的值，也可以使用value属性指定id，value属性名也可以省略注解
注解 id值
@Component commonComponent
public class CommonComponent {
}
@Controller(value="neueduBookAction" ) neueduBookAction
public class BookAction {
}
@Service("happyService" ) happyService
public class BookService {
}
实验31：通过注解分别创建Dao、Service、Controller★
实验32：使用context:include-filter指定扫描包时要包含的类
实验33：使用context:exclude-filter指定扫描包时不包含的类
< context:component-scan base-package ="com.neuedu.ioc.bean"/>
[1]base-package属性指定一个需要扫描的基类包，Spring容器将会扫描这个基类包及其子包中的所有类。
[2]当需要扫描多个包时可以使用逗号分隔,
[3]如果仅希望扫描特定的类而非基包下的所有类，可使用resource-pattern属性过滤特定的类，示例：
<context:component-scan base-package="com.neuedu.component" resource-pattern="autowire/*.class"/>
[4]包含与排除
●<context:include-filter>子节点表示要包含的目标类
注意：通常需要与use-default-filters属性配合使用才能够达到“仅包含某些组件”这样的效果。
即：通过将use-default-filters属性设置为false，禁用默认过滤器，然后扫描的就只是include-filter中的规则
指定的组件了。
●<context:exclude-filter>子节点表示要排除在外的目标类
●component-scan下可以拥有若干个include-filter和exclude-filter子节
⑤使用注解进行自动装配：@Autowired注解[好处就是：连get、set方法都不用写！]
[1]首先检测标记了@Autowired注解的属性的类型
[2]根据类型进行装配
[3]如果指定类型的bean不止一个，那么根据需要被装配的属性的属性名做id的值，查找bean
[4]如果根据id值还是没有找到bean，可以使用@Qualifier注解手动指定要装配的bean的id.
实验34：使用@Autowired注解实现根据类型实现自动装配★
实验34[补充1]：如果资源类型的bean不止一个，默认根据@Autowired注解标记的成员变量名作为id查找bean，进行装配★
实验34[补充2]：如果根据成员变量名作为id还是找不到bean，可以使用@Qualifier注解明确指定目标bean的id★
实验36：Autowired注解的required属性指定某个属性允许不被设置.
实验37：在类上使用注解@Scope可以指定对象是单实例还是多实例的！