Spring5
IOC容器
什么是IOC容器
1.什么是IOC（控制反转）
a) 把对象的创建和对象之间的调用交给，Spring管理
b) 使用IOC目的为降低耦合度
2.Spring提供的IOC容器实现的俩个接口
a) BeanFactory接口:加载配置文件的时候不创建对象，获取对象的时候才创建
b）ApplicationContext接口：加载配置文件的时候就会把配置文件的对象进行创建
IOC容器-Bean管理
1.IOC操作Bean管理
（1）创建对象 （2）注入属性
2.基于Xml创建对象
<bean id="user" class="com.atguigu.spring5.User"></bean>
3.基于Xml方式注入属性
（1）set方式注入
<bean id="book" class="com.atguigu.spring5.Book">
<property name="bname" value="Hello"></property>
<property name="bauthor" value="World"></property>
</bean>
（2）有参构造注入
<bean id="orders" class="com.atguigu.spring5.Orders">
<constructor-arg name="oname" value="Hello"></constructor-arg>
<constructor-arg name="address" value="China！"></constructor-arg>
</bean>
4.注入特殊符号
<bean id="book" class="com.atguigu.spring5.Book">
<!--（1）null值-->
<property name="address">
<null/><!--属性里边添加一个null标签-->
</property>
<!--（2）特殊符号赋值-->
<!--属性值包含特殊符号
a 把<>进行转义 < >
b 把带特殊符号内容写到CDATA
-->
<property name="address">
<value><![CDATA[<<南京>>]]></value>
</property>
</bean>
5.通过外部Bean注入
<!--1 service和dao对象创建-->
<bean id="userService" class="com.atguigu.spring5.service.UserService">
<!--注入userDao对象
name属性：类里面属性名称
ref属性：创建userDao对象bean标签id值
-->
<property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>
6.设置对象值
<!--第一步：在 spring 配置文件中引入名称空间 util-->
<?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:util="http://www.springframework.org/schema/util" <!--添加util名称空间-->
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"> <!--添加util名称空间-->
<!--第二步：使用 util 标签完成 list 集合注入提取-->
<!--把集合注入部分提取出来-->
<!--1 提取list集合类型属性注入-->
<util:list id="bookList">
<value>易筋经</value>
<value>九阴真经</value>
<value>九阳神功</value>
</util:list>
<!--2 提取list集合类型属性注入使用-->
<bean id="book" class="com.atguigu.spring5.collectiontype.Book" scope="prototype">
<property name="list" ref="bookList"></property>
</bean>
BeanFactory
1.IOC 操作 Bean 管理（FactoryBean）
1、Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）
2、普通 bean：在配置文件中定义 bean 类型就是返回类型
3、工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样 第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean 第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型
2.单实例与多实例
1）在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例
（2）scope 属性值 第一个值 默认值，singleton，表示是单实例对象 第二个值 prototype，表示是多实例对象
<bean id="book" class="com.atguigu.spring5.collectiontype.Book" scope="prototype"><!--设置为多实例-->
<property name="list" ref="bookList"></property>
</bean>
注：单实例和多实例的区别
singleton:加载Spring文件的时候会创造单实例对象
prototype:加载Spring文件的时候创造多实例对象
Bean的生命周期
Bean生命周期
（1）在通过构造器构造bean实例（无参构造）
（2）为bean属性设置值和对其他bean引用（调用set方法）
（3）把bean实例传给bean后置处理器方法postProcessBeforeInitialization
（4）调用bean的初始化方法（需要配置初始化方法）
（5）把bean实例传给bean后置处理器方法postProcessAfterInitialization
（6）bean对象获取到
（7）bean销毁
public class Orders {
//无参数构造
public Orders() {
System.out.println("第一步 执行无参数构造创建 bean 实例");
}
private String oname;
public void setOname(String oname) {
this.oname = oname;
System.out.println("第二步 调用 set 方法设置属性值");
}
//创建执行的初始化的方法
public void initMethod() {
System.out.println("第四步 执行初始化的方法");
}
//创建执行的销毁的方法
public void destroyMethod() {
System.out.println("第七步 执行销毁的方法");
}
}
public class MyBeanPost implements BeanPostProcessor {//创建后置处理器实现类
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("第三步在初始化之前执行的方法");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("第五步在初始化之后执行的方法");
return bean;
}
}
<!--配置文件的bean参数配置-->
<bean id="orders" class="com.atguigu.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod"> <!--配置初始化方法和销毁方法-->
<property name="oname" value="手机"></property><!--这里就是通过set方式（注入属性）赋值-->
</bean>
<!--配置后置处理器-->
<bean id="myBeanPost" class="com.atguigu.spring5.bean.MyBeanPost"></bean>
@Test
public void testBean3() {
// ApplicationContext context =
// new ClassPathXmlApplicationContext("bean4.xml");
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("bean4.xml");
Orders orders = context.getBean("orders", Orders.class);
System.out.println("第六步 获取创建 bean 实例对象");
System.out.println(orders);
//手动让 bean 实例销毁
context.close();
}
Druid连接池
配置德鲁伊连接池
<?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"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<context:component-scan base-package="SwJdbc"></context:component-scan>
<context:property-placeholder location="x.properties"></context:property-placeholder>
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${driverclass}"></property>
<property name="url" value="${url}"></property>
<property name="password" value="${password}"></property>
<property name="username" value="${user}"></property>
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--创建事物管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--开启事物注解-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
</beans>
</beans>
IOC基于注解方式管理Bean
1.创建bean对象的注解
以下四个注解实现功能相同
（1）@Component
（2）@Service
（3）@Controller
（4）@Repository
第一步：开启组件扫描
<!--开启组件扫描
1 如果扫描多个包，多个包使用逗号隔开
2 扫描包上层目录
-->
<context:component-scan base-package="com.atguigu"></context:component-scan>
第二步：创建类
//在注解里面 value 属性值可以省略不写，
//默认值是类名称，首字母小写
//UserService -- userService
@Component(value = "userService") //注解等同于XML配置文件：<bean id="userService" class=".."/>
public class UserService {
public void add() {
System.out.println("service add.......");
}
}
细节配置
<!--示例 1
use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
context:include-filter ，设置扫描哪些内容
-->
<context:component-scan base-package="com.atguigu" use-defaultfilters="false">
<context:include-filter type="annotation"
expression="org.springframework.stereotype.Controller"/><!--代表只扫描Controller注解的类-->
</context:component-scan>
<!--示例 2
下面配置扫描包所有内容
context:exclude-filter： 设置哪些内容不进行扫描
-->
<context:component-scan base-package="com.atguigu">
<context:exclude-filter type="annotation"
expression="org.springframework.stereotype.Controller"/><!--表示Controller注解的类之外一切都进行扫描-->
</context:component-scan>
2.属性注入
（1）@Autowired：根据属性类型进行自动装配
第一步：把service和dao对象创建，在service和dao上添加创建对象注解
第二步：在service中注入dao对象，在service中添加dao属性，在属性上使用注解
@Service
public class UserService {
//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired
private UserDao userDao;
public void add() {
System.out.println("service add.......");
userDao.add();
}
}
//Dao实现类
@Repository
//@Repository(value = "userDaoImpl1")
public class UserDaoImpl implements UserDao {
@Override
public void add() {
System.out.println("dao add.....");
}
}
（2）@Qualifier：根据名称注入，要配合@Autowired使用
//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired //根据类型进行注入
//根据名称进行注入（目的在于区别同一接口下有多个实现类，根据类型就无法选择，从而出错！）
@Qualifier(value = "userDaoImpl1")
private UserDao userDao;
（3）@Value：注入普通属性
@Value(value = "abc")
private String name
3.完全注解开发
编写配置类，代替xml
@Configuration //作为配置类，替代 xml 配置文件
@ComponentScan(basePackages = {"com.atguigu"})
public class SpringConfig {
}
AOP
AOP基本概念
基本概念
面向切面编程，利用AOP可以对业务逻辑等各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可复用性，同时提高开发效率。
AOP术语
1）连接点：类中可以被增强的方法
2）切入点：实际上被增强的方法
3）通知（增强）：实际增强的部分
分为：前置通知，后置通知，环绕通知，异常通知，最终通知
4）切面：把通知应用于切入点的过程
AOP动态代理
1）JDK动态代理：创建接口实现类对象，来增强方法
2）CGLIB动态代理：创建子类的代理对象，增强方法
1.JDK动态代理
public class JDKProxy {
public static void main(String[] args) {
//创建接口实现类
Dao dao = (Dao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), new Class[]{Dao.class}, new DaoProxy(new DaoImp()));
int add = dao.add(1, 2);
//System.out.println(add);
}
}
class DaoProxy implements InvocationHandler{
private Object obj;
public DaoProxy(Object obj){
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("方法执行前..."+method.getName()+ Arrays.toString(args));
Object invoke = method.invoke(obj, args);
System.out.println("方法执行后....");
return invoke;
}
}
AOP操作（AspectJ注解）
a）Spring 框架一般都是基于 AspectJ 实现 AOP 操作，AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使 用，进行 AOP 操作
b）基于 AspectJ 实现 AOP 操作：1）基于 xml 配置文件实现 （2）基于注解方式实现（使用）
c）引入相关jar包
d）切入点表达式，如下：
（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强
（2）语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )
（3）例子如下：
例 1：对 com.atguigu.dao.BookDao 类里面的 add 进行增强
execution(* com.atguigu.dao.BookDao.add(..))
例 2：对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强
execution(* com.atguigu.dao.BookDao.* (..))
例 3：对 com.atguigu.dao 包里面所有类，类里面所有方法进行增强
execution(* com.atguigu.dao.*.* (..))
<!--3、进行通知的配置-->
<?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"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 开启注解扫描 -->
<context:component-scan base-package="com.atguigu.spring5.aopanno"></context:component-scan>
<!-- 开启Aspect生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
//增强的类
@Component
@Aspect //生成代理对象
@Order(1) //设置优先级
public class UserProxy {}
//被增强的类
@Component
public class User {}
//4、配置不同类型的通知
@Component
@Aspect //生成代理对象
public class UserProxy {
//相同切入点抽取
@Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void pointdemo() {
}
//前置通知
//@Before注解表示作为前置通知
@Before(value = "pointdemo()")//相同切入点抽取使用！
public void before() {
System.out.println("before.........");
}
//后置通知（返回通知）
@AfterReturning(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void afterReturning() {
System.out.println("afterReturning.........");
}
//最终通知
@After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void after() {
System.out.println("after.........");
}
//异常通知
@AfterThrowing(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void afterThrowing() {
System.out.println("afterThrowing.........");
}
//环绕通知
@Around(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前.........");
//被增强的方法执行
proceedingJoinPoint.proceed();
System.out.println("环绕之后.........");
}
}
XML方式
<!--1、创建两个类，增强类和被增强类，创建方法（同上一样）-->
<!--2、在 spring 配置文件中创建两个类对象-->
<!--创建对象-->
<bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>
<!--3、在 spring 配置文件中配置切入点-->
<!--配置 aop 增强-->
<aop:config>
<!--切入点-->
<aop:pointcut id="p" expression="execution(* com.atguigu.spring5.aopxml.Book.buy(..))"/>
<!--配置切面-->
<aop:aspect ref="bookProxy">
<!--增强作用在具体的方法上-->
<aop:before method="before" pointcut-ref="p"/>
</aop:aspect>
</aop:config>
JdbcTemplate
JdbcTemplate概念及使用
a）Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作
b）引入相关 jar 包
c）在 spring 配置文件配置数据库连接池
<context:property-placeholder location="x.properties"></context:property-placeholder>
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${driverclass}"></property>
<property name="url" value="${url}"></property>
<property name="password" value="${password}"></property>
<property name="username" value="${user}"></property>
</bean>
d）注入DataSource
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
e）创建service类，创建dao类，在dao中注入JdbcTemplate
<!-- 组件扫描 -->
<context:component-scan base-package="com.atguigu"></context:component-scan>
@Service
public class BookService {
//注入 dao
@Autowired
private BookDao bookDao;
}
@Repository
public class BookDaoImpl implements BookDao {
//注入 JdbcTemplate
@Autowired
private JdbcTemplate jdbcTemplate;
}
JdbcTemplate的增删改查
@Service
public class Dao implements DaoBk {
//注入JdbcTemplate
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public int add(fruit fruit) {
String sql = "insert into test_test values (?,?,?,?)";
int update = jdbcTemplate.update(sql, fruit.getName(), fruit.getPrice(), fruit.getCount(), fruit.getRemark());
return update;
}
@Override
public void delete(String name) {
String sql = "delete from test_test where name = ?";
int update = jdbcTemplate.update(sql, name);
return;
}
@Override
public int selectCount() {
String sql = "select count(*) from test_test";
Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
return integer;
}
@Override
public fruit fine() {
String sql = "select * from test_test where name = ?";
fruit fruit = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<fruit>(fruit.class),"苹果");
return fruit;
}
@Override
public List<fruit> findAll() {
String sql = "select * from test_test";
List<fruit> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<fruit>(fruit.class));
return query;
//多重返回值用query
}
@Override //批量添加
public void batchAdd(List<Object[]> list) {
String sql = "insert into t_book values(?,?,?)";
int[] ints = jdbcTemplate.batchUpdate(sql, list);
System.out.println(1);
}
@Override
public void batchUpdateAdd(List<Object[]> list) {
String sql = "update test_test set price = ? where name = ?";
int[] ints = jdbcTemplate.batchUpdate(sql, list);
System.out.println(1);
}
@Override
public void update(fruit fruit) {
String sql = "update test_test set price = ? where name = ?";
Object[] args = {fruit.getPrice(),fruit.getName()};
int update = jdbcTemplate.update(sql, args);
return;
}
}
Spring中事务操作
事务的概念
a）什么是事务
（1）事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操 作都失败
（2）典型场景：银行转账 张三 转账 100 元 给 李四； 张三少 100，李四多 100
b）事务四个特性（ACID） （1）原子性 （2）一致性 （3）隔离性 （4）持久性
事务操作
1、事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）
2、在 Spring 进行事务管理操作 ；两种方式：编程式事务管理、声明式事务管理（推荐使用）
3、声明式事务管理 （1）基于注解方式（推荐使用） （2）基于 xml 配置文件方式
4、在 Spring 进行声明式事务管理，底层使用 AOP 原理
5、Spring 事务管理 API ：提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类
<!--创建事物管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--开启事物注解-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
@Service
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ,timeout = -1,readOnly = false)
public class Daoservice {
@Autowired
private Dao dao;
public void countMoney(){
dao.add();
dao.reduce();
}
}
事务传播行为
propagation（事务传播行为）
a）在 service 类上面添加注解@Transactional，在这个注解里面可以配置事务相关参数
b）propagation（事务传播行为）：多事务方法直接进行调用，这个过程中事务 是如何进行管理的
c）spring框架事务传播行为有七种：下面只介绍常用的两种传播行为
@Transactional(propagation = Propagation.REQUIRED,) //事务一
public void add(){
//调用update方法
update();
}
public void update(){ //事务二
}
（1）REQUIRED:如果add方法本身有事务，调用update方法后，update使用当前add方法里面的事务；
（2）REQUIRED_NEW：使用add调用update方法，不论add方法是否有事务，都会创建新的事务。
ioslation（事务隔离级别）
a）事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题
b）有三个读问题：脏读、不可重复读、虚（幻）读
脏读： 一个未提交事务读取到另一个未提交事务的数据
不可重复读： 一个未提交事务读取到另一提交事务修改数据
虚读： 一个未提交事务读取到另一提交事务添加数据
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
超时间：Timeout
（1）事务需要在一定时间内进行提交，如果不提交进行回滚 （2）默认值是 -1（不超时） ，设置时间以秒单位进行计算
readOnly：是否只读
（1）读：查询操作，写：添加修改删除操作
（2）readOnly 默认值 false，表示可以查询，可以添加修改删除操作
（3）设置 readOnly 值是 true，设置成 true 之后，只能查询
rollbackFor：回滚
设置出现哪些异常进行事务回滚
noRollbackFor：不回滚
设置出现哪些异常不进行事务回滚
