Spring5框架课堂笔记.pdf

1.AOP相关内容

1.1AOP概念

1.什么是AOP？
（1）面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
（2）通俗描述：不通过修改源代码的方式，在主干功能里面添加新功能
（3）我们使用登录的例子来说明AOP，如下

1.2 AOP 原理

1.3 AOP（jdk动态代理）

1.使用JDK动态代理，使用Proxy类里面的方法创建对象 java.long.Proxy
(1)调用 newProxyInstance
方法有3个参数： 第一参数：类加载器 第二参数：增强方法所在的类，这个类实现的接口，支持多个接口 第三参数：实现这个接口InvocationHandler，创建代理对象，写增强的方法 2.JDK动态代理代码 （1）创建接口，定义方法 public interface UserDao { public int add(int a,int b); public String update(String id); } （2）创建接口的实现类 public class UserDaoImpl implements UserDao { @Override public int add(int a, int b) { return a+b; } @Override public String update(String id) { return id; } } （3）使用Proxy类创建接口代理对象 public class JDKProxy { public static void main(String[] args) { //创建接口实现类的代理对象 Class[] interfaces = {UserDao.class}; // Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), new InvocationHandler() { // @Override // public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // return null; // } // }) UserDao userDao = new UserDaoImpl(); UserDao dao = (UserDao)Proxy.newProxyInstance( JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao) ); int add = dao.add(1, 2); System.out.println(“resault：”+add); } } class UserDaoProxy implements InvocationHandler{ //1.把创建的是谁的代理对象，把谁传递过来 // 有参数的构造 private Object obj; public UserDaoProxy(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 res = method.invoke(obj, args); //方法之后 System.out.println(“方法之后”+obj); return res; } }

1.4 AOP(术语)

1.5 AOP操作(准备工作)

1.在spring框架中一般基于Aspectj实现AOP操作 （1）什么是Aspectj *不是spring组成部分， 独立AOP框架，一般把Aspectj和Spring框架一起使用，进行AOP操作 2.基于Aspectj实现AOP操作 （1）基于xml配置文件 （2）基于注解方式实现（使用） 3.在项目的工程里面引入jar包
4.切入点表达式 （1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强 （2）语法结构 excution([权限修饰符][返回类型][类的全路径]方法名称) 举例1：对com.atguigu.dao.BookDao类里的add进行增强 Execution( com.atguigu.dao.BookDao.add(..)) 举例2：对com.atguigu,daoBookDao里面的所有方法进行增强 execution( com.atguigu.dao.BookDao.(..)) 举例3：对包中所有类进行增强 execution( com.atguigu.dao..(..))

1.6.AOP操作（Aspectj注解）

1.创建类，在类中定义方法
public class User {
    private void add(){
        System.out.println("add.......");
    }
}
2.创建增强类
（1）在增强类中，创建方法，代表不同的通知
//增强类
public class UserProxy {
    //前置通知
    public void before(){
        System.out.println("before......");
    }
}
3.进行通知的配置
（1）在spring中，开启注解扫描
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"            >
    <!--开启注解扫描-->
    <context:component-scan base-package="com.atguigu.spring5.aopanno"></context:component-scan>
（2）使用注解创建User和UserProxy对象
//增强类
@Component
public class UserProxy {
    //前置通知
    public void before(){
        System.out.println("before......");
    }
}
//被增强类
@Component
public class User {
    private void add(){
        System.out.println("add.......");
    }
}
（3）在增强类上添加注解@Aspect
//增强类
@Component
@Aspect  //生成代理对象
public class UserProxy {
（4）在spring的配置文件中开启生成代理对象
<!--开启Sspectj生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
4.配置不同类型的通知
（1）在增强类里面作为通知的方法上面，添加通知类型的注解，并使用切入点表达式进行配置
//增强类
@Component
@Aspect  //生成代理对象
public class UserProxy {
//前置通知
/*before 注解作为前置通知*/
@Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void before(){
    System.out.println("before......");
}
//after最终通知
@After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void after(){
    System.out.println("after.......");
}
//AfterReturning返回通知
@AfterReturning(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void AfterReturning(){
    System.out.println("AfterReturning.......");
}
//AfterThrowing 异常通知
@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("Around.......before");
    //被增强的方法
    proceedingJoinPoint.proceed();
    System.out.println("Around.......after");
}
5.相同的切入点抽取
//相同的切入点进行抽取
@Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void  pointcut(){
}
//前置通知
/*before 注解作为前置通知*/
@Before(value = "pointcut()")
public void before(){
    System.out.println("before......");
}
6.有多个增强类对同一个方法进行增强，可以设置增强类的优先级
（1）在增强类上添加注解Order（数字类型值），数字类型的值越小优先级越高
@Component
@Aspect
@Order(1)
public class PersonProxy {
    //相同的切入点进行抽取
    @Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void  pointcut(){
    }
    //前置通知
    /*before 注解作为前置通知*/
    @Before(value = "pointcut()")
    public void before(){
        System.out.println("person   before......");
    }
}

1.7. AOP操作(Aspectj配置文件)

1.创建两个类，一个增强一个被增强
2.在spring的配置文件中创建两个类对象
<!--创建两个类对象-->
<bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>
3.xml配置切入点
<!--配置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:before>
     </aop:aspect>
</aop:config>
7.完全使用注解开发，创建配置类，不需要创建xml配置文件
@Configuration
@ComponentScan(basePackages = {"com.atguigu"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class springConfig {
}

2. IOC 容器

2.1. IOC底层原理

【1】概念和原理

• 控制反转，把对象的创建和对象之间的调用过程，交给spring进行管理，
  
• IOC目的：为了耦合度降低

• 做入门案例就是IOC实现
  

  【2】IOC底层原理

• xml解析，工厂设计模式，反射
  

  【3】画图解析

—-xml解析

2.2 IOC接口（BeanFactory）

【1】IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

【2】Spring提供IOC容器实现两种方式：（两个接口）

    (1)BeanFactory:IOC容器基本完成，是Spring内部的使用接口，不提供给开发人员使用

• 加载配置文件时不会创建对象，在获取对象（使用对象才会创建）
  

  (2)ApplicationContext：BeanFactory接口的子接口，提供更加强大的功能，一般由开发人员使用

• 加载配置文件时，就会把你在配置文件中的对象进行创建
  

  【3】Application接口实现类

         ![image.png](https://cdn.nlark.com/yuque/0/2021/png/22433412/1629276596937-2ae53c63-6d25-4895-b0b3-6ae5185e705f.png#align=left&display=inline&height=58&margin=%5Bobject%20Object%5D&name=image.png&originHeight=58&originWidth=358&size=4580&status=done&style=none&width=358)

• classpath 类路径

• filesystem 盘符路径

  2.3. IOC操作Bean管理（概念）

  【1】Bean管理

• Bean管理指的是两个操作
  

  • Spring创建对象
    

  • Spring注入属性
    

    【2】Bean管理操作由两种操作方式

  • 基于xml配置文件方式实现
    

  • 基于注解方式实现

    2.4.IOC操作Bean管理（基于xml方式）

    【1】基于xml方式创建对象

    ![image.png](https://cdn.nlark.com/yuque/0/2021/png/22433412/1629276704463-c673df98-0077-47cc-9c78-83f585ae40ab.png#align=left&display=inline&height=71&margin=%5Bobject%20Object%5D&name=image.png&originHeight=71&originWidth=738&size=6064&status=done&style=none&width=738)

• 在Spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象的创建
  

• 在bean标签有很多属性，介绍常用的属性
  
  • id属性 ：唯一标识
    
  • class属性：创建对象所在类的全路径
    
  • name属性：同id（区别：可以加特殊符号，不常用）
    

• 创建对象的时候，默认也是执行无参的构造方法
  

  【2】基于xml方式注入属性

• DI：依赖注入，就是注入属性（先创建对象）

  • 1.使用set方法
    

    • 创建一个类，定义属性和对应的set方法
      
    • 
      
    • 在spring配置文件中配置对象创建，配置属性注入
      
      • 
        

  • 2.使用有参数的构造进行注入
    

    • 创建一个类，定义属性，有参数的构造方法
      
      • 
        
    • 在spring配置文件中进行配置
      
      • 
      • 也可以通过index决定参数位置
  • 3.p名称空间注入（了解）
    
    • 使用p名称空间注入，可以简化基于xml配置方式
      
      • 添加一个p名称空间在配置文件
      • 进行属性注入，在bean标签里面操作

        <beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       xmlns:p="http://www.springframework.org/schema/p"       xsi:schemaLocation="http://www.springframework.org/schema/beans                 http://www.springframework.org/schema/beans/spring-beans.xsd">
        <!--p名称空间-->
        <!--创建对象,注入属性-->
        <bean id="book"
        class="com.atguigu.spring5.Book"
        p:bname="九阳神功"
        p:bauthor="无名氏">
        </bean>

        2.5.IOC操作Bean管理（xml注入其他类型属性）

        【1】字面量 设置属性固定值 property标签设置值 ```xml (1)null值

(2)属性值包含特殊符号 <![CDATA[<<南京>>]]>

【2】注入属性-外部bean<br />        （1）创建两个类    service     dao<br />        （2）service调用dao方法<br />        （3）在spring的配置文件中配置】
```java
public class UserService {
    //创建UserDao类型属性，生产对应set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void add(){
        System.out.println("service add");
        userDao.Update();
    }
}
<!--service和dao对象创建-->
<bean id="userService" class="com.atguigu.spring5.service.UserService">
    <!--注入userDao对象
        name属性值：类的属性名称
        ref属性值：创建userdao对象bena标签的id
    -->
    <property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>
@Test
public void testBook1(){
    //加载xml配置文件
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean2.xml");
    //获取创建的对象
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
}

【3】注入属性-内部bean<br />        （1）1对多的关系：部门    员工 ； 部门是1   员工是多<br />        （2）在实体类之间表示1对多的关系  员工所属部门，使用对象类型表示

/**
* 部门类
*/
public class Dept {
    private String dname;
    public void setDname(String dname) {
        this.dname = dname;
    }
}
//员工类
public class Emp {
    private String ename;
    private String gender;
    //员工属于某一个部门
    private Dept dept;
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public void add(){
    System.out.println(ename+" "+gender+" "+dept);
}
}
  public void testBean2(){
    //加载xml配置文件
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean3.xml");
    //获取创建的对象
    Emp emp = context.getBean("emp", Emp.class);
    emp.add();
}

    （3）在spring中配置文件中配置

<!--内部bean-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
    <!--先设置两个普通的属性-->
    <property name="ename" value="lucy"></property>
    <property name="gender" value="nv"></property>
    <!--对象类型属性-->
    <property name="dept" >
        <bean id="dept" class="com.atguigu.spring5.bean.Dept">
            <property name="dname" value="anbao"></property>
        </bean>
    </property>
</bean>

【4】注入属性，级联赋值

第一种写法：
<!--级联赋值-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
    <!--先设置两个普通的属性-->
    <property name="ename" value="lucy"></property>
    <property name="gender" value="nv"></property>
    <!--级联赋值-->
    <property name="dept" ref="dept">
    </property>
</bean>
<bean id="dept" class="com.atguigu.spring5.bean.Dept">
     <property name="dname" value="caiwu"></property>
</bean>
第二种写法：需要生成dept的get方法
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
    <!--先设置两个普通的属性-->
    <property name="ename" value="lucy"></property>
    <property name="gender" value="nv"></property>
    <!--级联赋值-->
    <property name="dept" ref="dept"></property>
    <property name="dept.dname" value="技术部门"></property>
</bean>
<bean id="dept" class="com.atguigu.spring5.bean.Dept"></bean>

2.6.IOC操作Bean管理（xml注入集合属性）

1.注入数组类型的属性
2.注入List集合类型属性
3.注入map集合类型属性
    （1）创建类，定义数组  list  map   set集合属性
    （2）设置set函数
public class Stu {
    //1.数组类型属性
    private String[] course;
    //2.list集合属性
    private List<String> list;
    //3.map集合属性
    private Map<String,String> maps;
    //4.set集合属性
    private Set<String> sets;
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }
    public void setCourse(String[] course) {
        this.course = course;
    }
}
   （3）在spring配置文件中进行配置
<!--1.集合类型属性的注入-->
<bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
    <!--2.数组类型的属性注入-->
    <property name="course">
        <array>
            <value>java课程</value>
            <value>数据库</value>
            <value>python</value>
        </array>
    </property>
    <!--3.list集合属性注入-->
    <property name="list">
        <list>
            <value>张三</value>
            <value>小三</value>
        </list>
    </property>
    <!--4.map类型属性注入-->
    <property name="maps">
        <map>
            <entry key="JAVA" value="java"></entry>
            <entry key="PHP" value="php"></entry>
        </map>
    </property>
    <!--5.set集合属性注入-->
    <property name="sets">
        <set>
            <value>MySQL</value>
            <value>Redis</value>
        </set>
    </property>
</bean>
4.在集合中设置对象类型
    <!--1.集合类型属性的注入-->
    <bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
       <!--注入list集合类型，值是对象-->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>
    <!--创建多个course对象-->
    <bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
        <property name="cname" value="Spring5框架课程"></property>
    </bean>
    <bean id="course2" class="com.atguigu.spring5.collectiontype.Course">
        <property name="cname" value="MyBytis框架课程"></property>
    </bean>
5.集合注入部分提取出来
    （1）在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"
           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/beans/spring-util.xsd">
    （2）使用util标签完成list集合抽取
    <!--list集合属性注入提取-->
      <util:list id="bookList">
          <value>易筋经</value>
          <value>九阳神功</value>
          <value>九阴真经</value>
      </util:list>
    <!--提取注入【使用】-->
    <bean id="book" class="com.atguigu.spring5.collectiontype.Book">
        <property name="list" ref="bookList"></property>
    </bean>

2.7.IOC操作Bean管理（FactoryBean）

1.Spring中有两种类型的bean  一种不同的bean，一种工厂Bean（FactoryBean）
2.普通Bean：在spring的配置文件中，定义的类型就是返回类型
3.工厂Bean：在配置文件中定义的类型可以不一样
    第一步： 创建类，让这个类作为工厂Bean，接口实现FactoryBean
    第二部： 实现接口的方法，在实现的方法中定义返回的Bean类型
public class MyBean implements FactoryBean<Course> {
    //定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }
    @Override
    public Class<?> getObjectType() {
        return null;
    }
    @Override
    public boolean isSingleton() {
        return false;
    }
}
@Test
public void testCollectiion2(){
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean3.xml");
    Course myBean = context.getBean("myBean", Course.class);
    System.out.println(myBean);
}

2.8.IOC操作Bean管理（bean作用域）

1.在spring里面可以设置创建bean实例是单实例还是多实例
2.在Spring里面默认情况下，bean是单实例对象
3.如何设置是单实例还是多实例
（1）在spring配置文件的bean里面有一个标签（scope）用于设置单实例还是多实例
（2）scope属性值
    第一个值  默认值，singleton，单实例对象
    第二个值 prototype表示多实例对象
<bean scope="prototype" id="book" class="com.atguigu.spring5.collectiontype.Book">
    <property name="list" ref="bookList"></property>
</bean>
（3）singleton和prototype区别
    第一 singleton表示单实例，prototype表示多实例
    第二 设置scope值是singleton时，加载配置文件会创建单实例对象
         设置scope值是prototype时，不是在加载文件时创建，在调用getbean（）时才会创建

2.9.IOC操作Bean管理（bean生命周期）

1.生命周期
（1）从对象创建到对象销毁的过程
2.Bean的生命周期
（1）通过构造器创建bean实例（无参数构造）
（2）为bean的属性设置值和对其他bean的引用（调用set方法）
    初始化之前：把bean的实例传递给bean的后置处理器的方法postProcessBeforeInitialization
（3）调用bean的初始化方法（需要进行配置初始化方法）
    初始化之后：把bean的实例传递给bean的后置处理器的方法postProcessAfterInitialization
（4）bean可以使用了（对象获取到了）
（5）当容器关闭时，调用bean的销毁方法（需要进行配置销毁方法）
3.演示bean的生命周期
public class Orders {
    private String oname;
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("2，调用set方法设置属性的值");
    }
    //无参数的构造
    public Orders(){
        System.out.println("1，无参数构造，创建了bean的实例");
    }
    //创建执行初始化方法
    public void init(){
        System.out.println("3，执行初始化方法");
    }
    //创建销毁方法
    public void destory(){
        System.out.println("5.执行销毁方法");
    }
}
@Test
public void test3(){
    ApplicationContext context =
            new ClassPathXmlApplicationContext("bean4.xml");
    Orders orders = context.getBean("orders", Orders.class);
    System.out.println("4获取到了bean实例对象");
    System.out.println(orders);
    //手动销毁bean实例
    ((ClassPathXmlApplicationContext)context).close();
}
4.演示添加后置处理器的效果
（1）创建一个类，实现接口BeanPostProcessor
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 id="myBeanPost" class="com.atguigu.spring5.bean.MyBeanPost"></bean>

2.10.IOC操作Bean管理（xml自动装配）

1.什么是自动装配
（1）根据指定装配规则（属性名称或属性类型），spring自动将匹配的属性值进行注入
2.演示自动装配
（1）根据属性的名称惊醒自动装配
    <bean id="emp" autowire="byName" class="com.atguigu.spring5.autowire.Emp">
        <!--<property name="dept" ref="dept"></property>-->
    </bean>
    <bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
（2）根据属性类型进行注入
    <bean id="emp" autowire="byType" class="com.atguigu.spring5.autowire.Emp">
<!--        <property name="dept" ref="dept"></property>-->
    </bean>
    <bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

2.11.IOC操作Bean管理（引入外部属性文件）

1.直接配置数据库信息
（1）配置德鲁伊连接池
（2）引入德鲁伊连接池jar包
<!--直接配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
    <property name="username" value="root"></property>
    <property name="password" value="000823"></property>
</bean>
2.引入外部属性文件配置数据库连接池
（1）创建一个外部的属性文件，properties文件，数据库信息
    prop.driverClass=com.mysql.jdbc.Driver
    prop.url=jdbc:mysql://localhost:3306/userDb
    prop.username=root
    prop.password=root
（2）把外部的properties文件引入spring文件中
（3）引入名称空间context
<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/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"
>
（4）在spring配置文件中使用标签引入外部文件
<context:property-placeholder location="classpath:jdbc.properties"/>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${prop.driverClass}"></property>
    <property name="url" value="${prop.url}"></property>
    <property name="username" value="${prop.username}"></property>
    <property name="password" value="${prop.password}"></property>
</bean>

2.12.IOC操作Bean管理（基于注解方式）

1.什么是注解
（1）注解是代码特殊标记，格式：@注解名称（属性名称=属性值，......）
（2）使用注解，注解作用在类，方法，属性
（3）使用注解的目的：简化xml配置
2.Spring针对Bean管理中的操作对象提供注解
（1）@Component
（2）@Service
（3）@Controller
（4）@Repository
*功能一样，都可以用来创建bean实例
3.基于注解方式实现对象的创建
第一步：引入依赖 aop
第二步：开启组件扫描
  <!--开启组件扫描-->
  <!--扫描多个包，包之间使用逗号隔开-->
  <!--写扫描包的上层目录-->
  <context:component-scan base-package="com.atguigu.spring5"/>
第三步：创建类，在类上添加注解
//在注解里面的value可以不写
//默认是类名称，首字母小写
/*UserService--userService*/
@Service(value = "userService")//<bean id="userService" class="路径"/>
public class UserService {
    public void add(){
        System.out.println("service  add....");
    }
}
4.开启组件扫描的配置
<!--示例1
      use-default-filters="false"   表示现在不使用默认filter，自己配置filter
-->
<context:component-scan base-package="com.atguigu" use-default-filters="false">
    <context:include-filter type="annotation"
          expression="org.springframework.stereotype.Service"/>
</context:component-scan>
<!--示例2
    下面的配置扫描包里面所有的内容：
    context:exclude-filter  设置那些内容不进行扫描
-->
<context:component-scan base-package="com.atguigu">
    <context:exclude-filter type="annotation"
                            expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
5.基于注解方式实现属性的注入
（1）@Autowired：根据属性类型进行自动装配
第一步：把service和dao对象创建，在service和dao添加创建注解
第二步：在service注入dao对象，在service添加dao的类型属性
@Service(value = "userService")//<bean id="userService" class="路径"/>
public class UserService {
    //dao类型属性
    //不需要set方法
    //添加注解
    @Autowired
    private UserDao userDao ;
    public void add(){
        System.out.println("service  add....");
        userDao.add();
    }
}
（2）@Qualifer：根据属性名称进行注入
这个注解的使用，和@Auotwired一起使用
//dao类型属性
//不需要set方法
//添加注解
@Autowired//根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据类名称注入
private UserDao userDao ;
（3）@Resourse：可以根据类型注入，也可以根据名称注入
//    @Resource  //根据你的类型进行注入
    @Resource(name = "userDaoImpl1")
    private UserDao userDao;
（4）@Value：注入普通类型属性
@Value(value = "abc")
private String name;
6.纯注解开发
（1）创建配置类，替代xml配置文件
@Configuration   //作为配置类，替代xml文件
@ComponentScan(basePackages = {"com.atguigu"})
public class SpringConfig  {
}
（2）编写测试类
@Test
public void test2(){
    //加载配置类
    ApplicationContext context =
            new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService = context.getBean("userService", UserService.class);
    System.out.println(userService);
    userService.add();
}

3.JDBCTemplate

3.1 jdbcTemplate(概念和准备)

1.什么是JdbcTemplate
(1) Spring框架对Jdbc进行封装,使用jdbcTemplate方便实现数据库操作
2.准备工作
(1)引入jar包
一下还包括druidjar包

（2） 配置数据库连接池xml
    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
        destroy-method="close">
        <property name="url" value="jdbc:mysql:///user_db" />
        <property name="username" value="root" />
        <property name="password" value="000823" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>
（3）配置JdbcTemplate对象，注入DataBase信息
<!-- 数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
      destroy-method="close">
    <property name="url" value="jdbc:mysql:///user_db" />
    <property name="username" value="root" />
    <property name="password" value="000823" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>
<!--创建JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
     <!--注入DataSource-->
     <property name="dataSource" ref="dataSource"></property>
</bean>
（4）创建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;
}

3.2.添加操作

1.对应数据库创建实体类
public class User {
    private String userId;
    private String username;
    private String ustatus;
    public String getUserId() {
        return userId;
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getUstatus() {
        return ustatus;
    }
    public void setUstatus(String ustatus) {
        this.ustatus = ustatus;
    }
}
2.编写service和dao
（1）dao操作添加
    update(String sql,Object... args)
 (2)调用JdbcTemplate对象里面的update方法能实现添加操作
有两个参数
第一个参数：sql语句
第二个参数：可变参数，设置SQL语句值
//添加方法
@Override
public void add(Book book) {
    //1.sql添加语句
    String sql = "insert into t_book values(?,?,?) ";
    //调用方法实现
    Object[] args = {book.getUserId(), book.getUsername(), book.getUstatus()};
    int update = jdbcTemplate.update(sql,args);
    System.out.println(update);
}
3.测试类
public class testBook {
    @Test
    public void testJdbc(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);
        bookService.addBook(new Book("1","java","a"));
    }
}

3.3.修改

1.修改和删除
//修改
public void updateBook(Book book){
    bookDao.updateBook(book);
}
//删除
public void deleteBook(String id){
    bookDao.delete(id);
}
  实现dao数据库操作
//修改
@Override
public void updateBook(Book book) {
    //1.sql语句
    String sql = "update t_book set username = ? , ustatus = ? where user_id = ?";
    Object[] args = {book.getUsername(), book.getUstatus(),book.getUserId()};
    int update = jdbcTemplate.update(sql, args);
    System.out.println(update);
}
//删除
@Override
public void delete(String id) {
    //1.sql语句
    String sql = "delete from t_book where user_id = ?";
    int update = jdbcTemplate.update(sql, id);
    System.out.println(update);
}
测试类
@Test
    public void testJdbcadd(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);
//        bookService.addBook(new Book("1","java","a"));
        //修改
//        bookService.updateBook(new Book("1","javaupup","atguigu"));
        //删除
        bookService.deleteBook("1");
}

3.4. jdbc查询操作（返回某个值）

1.查询表里有多少条记录
//查询表中的总记录数
public int findCount(){
    return bookDao.selectCount();
}
2.使用jdbcTemplate实现查询返回某个值的代码
有两个参数
第一个参数：SQL语句
第二个参数：返回类型
//查询表中记录数
@Override
public int selectCount() {
    String sql = "select count(*) from t_book";
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
    return count;
}
3.测试类型
queryForObject(String sql,Class<T> requiredType)

3.5.jdbc查询返回某个对象

1.查询返回对象：查询图书的详情页面
//查询返回对象
public Book findOne(String id){
    return bookDao.findBookInfo(id);
}
2.jdbc返回对象
queryForObject(String sql,RowMapper<T> rowMapper)
有三个参数
    第一个参数：SQL语句
    第二个参数：RowMapper
        本身是一个接口，返回不同类型数据，使用这个接口的实现类，可以实现数据封装
    第三个参数：SQL语句值
//查询返回对象
@Override
public Book findBookInfo(String id) {
    String sql = "select * from t_book where user_id = ?";
    Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
    return book;
}
3.测试
//查询返回详情数据
Book one = bookService.findOne("2");
System.out.println(one);

3.6.返回集合

jdbcTemplate.query(sql,new BeanPropertyRowMapper<Book>(Book.class));
1.查询分页
//查询返回集合
public List<Book> findAll(){
    return bookDao.findAllBook();
}
2.调用jdbc模板实现查询集合
有三个参数
第一个参数：SQL语句
第二个参数：RowMapper
    本身是一个接口，返回不同类型数据，使用这个接口的实现类，可以实现数据封装
第三个参数：SQL语句值
//多条记录
@Override
public List<Book> findAllBook() {
    String sql = "select * from t_book";
    List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
    return bookList;
}

3.7.jdbc数据库操作（批量操作）

1.批量操作（添加多个，删除多个）操作多条记录
2.JdbcTemplate批量添加
    batchUpdate(String sql,List<Object[]> batchA...)   int[]
    两个参数
        第一个参数：SQL语句
        第二个参数：List集合 ，添加多条记录的数据
代码实现
//批量添加
@Override
public void batchAddbook(List<Object[]> batchArgs) {
    String sql = "insert into t_book values(?,?,?) ";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}
测试
//批量添加
List<Object[]> batchArgs = new ArrayList<>() ;
Object[] o1 = {"5","acc","a"};
Object[] o2 = {"6","ccc","d"};
Object[] o3 = {"7","aac","delete"};
batchArgs.add(o1);
batchArgs.add(o3);
batchArgs.add(o3);
bookService.batchAdd(batchArgs);

3.批量修改
（1）service
//批量修改
public void batchUpdate(List<Object[]> batchArgs){
    bookDao.batchUpdateBook(batchArgs);
}
（2）dao
//批量修改
@Override
public void batchUpdateBook(List<Object[]> batchArgs) {
    String sql = "update t_book set username = ? , ustatus = ? where user_id = ?";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}
（3）test
List<Object[]> batchArgs = new ArrayList<>() ;
Object[] o1 = {"牛珂凡","nasdasd","1"};
Object[] o2 = {"atguigu","dfghjk","2"};
Object[] o3 = {"nkf","dfghjkl","3"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
bookService.batchUpdate(batchArgs);
4.批量删除
（1）service
//批量delete
public void batchDelete(List<Object[]> batchArgs){
    bookDao.batchDeleteBook(batchArgs);
}
（2）dao
//批量删除
@Override
public void batchDeleteBook(List<Object[]> batchArgs) {
    //1.sql语句
    String sql = "delete from t_book where user_id = ?";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}
（3）test
//批量删除
List<Object[]> batchUpdateDate = new ArrayList<>();
Object[] o1 = {"1"};
Object[] o2 = {"2"};
Object[] o3 = {"3"};
batchUpdateDate.add(o1);
batchUpdateDate.add(o2);
batchUpdateDate.add(o3);
bookService.batchDelete(batchUpdateDate);

4.事务操作

4.1 事务概念

1.什么是事务
（1）事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败，那么所有操作都失败
（2）典型场景：银行转账
*lucy 转账 100 给 mary
*lucy 少 100 ;mary 多 100
2.事务四大特性(ACID)
（1）原子性: 不可分割 ，要么都成功，如果有一个失败，那么所有操作都失败
（2）一致性: 操作之前和之后，总量不变
（3）隔离性: 多事务操作不会产生影响
（4）持久性: 提交之后，发生真正变化

4.2.事务操作(搭建事务操作环境)

1.创建数据库表，添加记录

2.创建servicce，搭建dao，完成对象的创建，相关的注入，配置连接池
（1）service注入dao，dao注入jdbcTemplate模板，在jdbcTemplate注入datasource
  <!--开启组件草庙-->
      <context:component-scan base-package="com.atguigu"></context:component-scan>
  <!-- 数据库连接池 -->
  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
  destroy-method="close">
      <property name="url" value="jdbc:mysql:///user_db" />
      <property name="username" value="root" />
      <property name="password" value="000823" />
      <property name="driverClassName" value="com.mysql.jdbc.Driver" />
  </bean>
  <!--创建JdbcTemplate对象-->
  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  <!--注入DataSource-->
  <property name="dataSource" ref="dataSource"></property>
  </bean>
service层
@Service
public class UserService {
    //注入dao
    @Autowired
    private UserDao userDao;
}
dao层
@Repository
public class UserDaoImpl implements UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
}
3.在Dao创建两个方法：多钱   少钱，在service创建方法转账
    dao
    //lucy转账100给mary
    //少钱的方法
    @Override
    public void reduceMoney() {
        String sql ="update t_account set money = monry-? where username = ?";
        int update = jdbcTemplate.update(sql,100,"lucy");
    }
    //多钱的方法
    @Override
    public void addMoney() {
        String sql ="update t_account set money = monry+? where username = ?";
        int update = jdbcTemplate.update(sql,100,"mary");
    }
    service
    @Service
    public class UserService {
        //注入dao
        @Autowired
        private UserDao userDao;
        //转账的方法
        public void accountMoney(){
            //lucy少100
            userDao.reduceMoney();
            //mary多100
            userDao.addMoney();
        }
    }
    test
    @Test
    public void testAccount(){
        ApplicationContext context
                = new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.accountMoney();
    }

数据库表中变化如下所示：

4.上面代码，如果正常执行时没有问题的，但是如果代码执行过程中出现异常，有问题

（1）上面的问题如何解决？
*使用事务进行解决
（2）事务操作过程

4.3.事务操作(Spring事务管理介绍)

1.事务添加JavaEE三层架构Service层（业务逻辑层）
2.在Spring进行事务管理操作 （1）有两种方式：编程式事务管理+声明式事务管理（使用）
3.声明式事务管理 （1）基于注解方式 （2）基于xml配置文件方式
4.在Spring进行声明式事务管理，底层使用AOP原理
5.Spring事务管理API （1）提供一个借口，代表事务管理器，这个接口根据不同的框架提供不同的实现类

4.4.事务操作（注解声明式事务管理）

1.在spring的配置文件中配置事务管理器 2.开启事务注解 （1）引入名称空间tx xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance“ 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 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd” xmlns:context=”http://www.springframework.org/schema/context“ xmlns:aop=”http://www.springframework.org/schema/aop“ xmlns:tx=”http://www.springframework.org/schema/tx“ > （2）开启事务注解

3.在service上面（获取service类里面方法上面，添加事务注解） （1）@Transactional，可以添加类上面也可以添加到方法上面 （2）如果把注解添加到类上面，所有方法都添加事务 （3）方法上面，只是为这个方法添加事务

4.5.事务管理（声明式事务管理参数配置）

1.在service类上添加@Transactional，可以配置相关参数
2.propagation() ：事务传播行为 （1）多事务方法直接进行调用，这个过程中事务是如何进行管理的
3.isolation():事务隔离级别 （1）事务有特性成为隔离性，多事务操作之间不会产生影响，不考虑隔离性产生很多问题 （2）有三个读的问题：脏读，不可重复读，幻读 （3）脏读：多个事务之间，一个未提交的事务读取到了另一个未提交事务的数据 （4）不可重复读：一个未提交的事务读取到另一提交事务修改的数据 （5）幻（虚）读：一个未提交事务读取到一个提交事务的添加的数据 （6）解决：通过设置事务隔离性，解决读问题
4.timeout():超时时间 （1）事务需要在一定时间内进行提交，如果不提交就会回滚 （2）默认值：-1，设置时间以秒为单位
5.readOnly()是否只读 （1）读：查询操作，写：添加修改删除操作 （2）默认值：false，表示可以查询，也可以添加修改删除 （3）设置：true，只能查询
6.rollbackFor():回滚 （1）设置出现哪些异常进行事务回滚
7.norollbackFor():不回滚 （1）设置出现那些异常不进行事务回滚

4.6.事务管理（xml声明式事务管理）

4.7.事务操作（完全注解开发）

5.Spring5框架新特性

5.1.整个Spring5框架的代码基于java8，运行时兼容jdk9，许多不建议使用的类和方法在代码库中删除

5.2.Spring5框架自带了通用的日志封装

（1）Spring5已经给我们移除了Log4jConfigListener，官方建议我们使用Log4j2 （2）Spring5框架整合Log4j2 第一步引入jar包 第二步 创建Log4j2.xml配置为文件

<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，可以看到log4j2内部各种详细输出-->
<configuration status="INFO">
    <!--先定义所有的appender-->
    <appenders>
        <!--输出日志信息到控制台-->
        <console name="Console" target="SYSTEM_OUT">
            <!--控制日志输出的格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </console>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    <!--root：用于指定项目的根日志，如果没有单独指定Logger，则会使用root作为默认的日志输出-->
    <loggers>
        <root level="info">
            <appender-ref ref="Console"/>
        </root>
    </loggers>
</configuration>