spring的框架概述

最新推荐文章于 2023-02-28 14:19:20 发布
最新推荐文章于 2023-02-28 14:19:20 发布
阅读量876 收藏
点赞数 1
文章标签： maven java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51386016/article/details/123897845
版权

spring的框架概述

1.spring是轻量级的开源javaee框架

2.spring可以解决企业应用开发的复杂性

3.spring有两个核心部分****ioc和aop

（1）ioc：控制反转，把创建对象过程交给spring进行管理

（2） Aop：面向切面，不修改源代码进行功能增强

4.# spring的特点

  1. 方便解耦，简化开发

  2. aop编程支持

  3. 方便程序测试

  4. 方便与其他框架进行整合

  5. 方便进行食物操作

  6. 降低api的开发难度

    ioc容器（概念和原理）

    1. 什么是ioc

    • 控制反转，把对象创建和对象之间的调用过程 ，交给spring进行管理。

    • 使用IOC目的，为了耦合度降低

    2.ioc底层原理*

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

    3.ioc（接口）

    1. ioc思想基于ioc容器完成，ioc容器底层就是对象工厂。

    2. Spring提供ioc容器实现两种方式：（两个接口）-

      1. BeanFactory：Ioc容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用,加载配置文件的时候不会创建对象，在获取对象（使用）才会去创建对象
        2. ApplicationContext：Beanfactory接口的子接口，提供更多更强大的功能。一般有开发人员使用。
        • 加载配置文件时候就会把配置文件对象进行创建
          3. ApplicationContext接口有实现类：
      * **主要****FileSystemXmlApplicationContext**
* **ClassPathXmlApplicationContext**-

      四.ioc操作Bean管理

      1. 什么是Bean管理

        • Bean管理指的是两个操作
          • spring创建对象
          • spring注入属性

      2. Bean管理操作的两种方式

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

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

        1. 基于xml方式创建对象

        2. 配置对象创建
<bean id="stu1" class="com.dhy.Student"/>
          • 在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
          • bean标签有很多属性，常用属性

          *id属性：唯一标识。

          *class属性：类全路径（包类路径

          创建对象时候，默认也是执行无参数构造方法完成对象创建

        3. 基于xml方式注入属性

          1.DI：依赖注入，就是注入属性。

          • 第一种注入方式：使用set方法进行注入

            • 创建类，定义属性对应的set方法

            • 在spring配置文件配置对象创建，配置属性注入

            • <property name="name" value="名字" ></property>

          • 第二种注入方式：使用有参数构造进行注入

            • 创建类，定义属性，创建有参构造方法

            • 在spring配置文件中进行配置

              <bean id="" class="">
<constructor-arg name="" value="">
<constructor-arg>
</bean>

        4.p名称空间注入

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

    1. 字面量

      • null值
      <property name="address">
<null/>
</property>

      • 属性值包含特殊符号

        1.把<>进行转义&lt：&gt
2.把带特殊符号内容写到CDATA
<property name="adress">
<value>
<![CDATA[<<南京>>]]>
<value>
</property>

    2. 注入属性-外部bean2

      • 创建两个类service和到类

      • 在service调用dao里面的方法

      • 在spring配置文件中进行配置

        <bean id="userService" class="包类名" >
<property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="包类名">

    3. 注入属性-内部bean和级联赋值

      *一对多关系：部门和员工，

      一个部门有多个员工，一个员工属于一个部门。部门是一，员工是多。

      <bean id="emp" class="org.pojo.Emp">
    <property name="ename" value="李三"/>
    <property name="eage" value="11"/>
    <property name="dept" >
        <bean id="userdept" class="org.pojo.Dept">
            <property name="dname" value="公关部"></property>
        </bean>
    </property>
</bean>

    4.注入属性-级联赋值

    <bean id="emp" class="org.pojo.Emp">
        <property name="ename" value="李三"/>
        <property name="eage" value="11"/>
        <property name="dept" ref="userdept"/>
    </bean>
<bean id="userdept" class="org.pojo.Dept">
<property name="dname" value="部门"></property>
</bean>

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

1.注入数组类型属性

2.注入List集合类型属性

3.注入Map集合类型属性

  • 创建类，定义数组，list，map，set类型属性，生成对应set方法

  • public class Stu {
    private String[] course;
    private List<String> list;
    private Map<String,String> map;
    private Set<String> sets;

    public void setCourse(String[] course) {
        this.course = course;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public void test(){
        System.out.println(Arrays.toString(course));
        System.out.println(map);
        System.out.println(sets);
        System.out.println(list);

    }
}

  • 在spring配置文件中进行配置

  • <bean id="stu" class="org.pojo.Stu">
    <property name="course">
        <array>
            <value>java课程</value>
            <value>c++</value>
        </array>
    </property>
    <property name="map">
        <map>
            <entry key="1" value="d"></entry>
            <entry key="2" value="h"></entry>
        </map>
    </property>
    <property name="list">
        <list>
            <value>张三</value>
            <value>小三</value>
        </list>
    </property>
    <property name="sets">
        <set>
            <value>JAVA</value>
        </set>
    </property>
</bean>

4.在集合里面设置对象类型值

  • <property name="courseList">
        <list>
            <ref bean="course1"></ref>
            <ref bean="course2"></ref>
        </list>
    </property>
</bean>
<bean id="course1" class="org.pojo.Course">
    <property name="cname" value="Spring框架"></property>
</bean>
<bean id="course2" class="org.pojo.Course">
    <property name="cname" value="mybatis框架"></property>
</bean>

5.把集合注入部分提取出来

  • 在spring配置文件中引入名称空间util

  • <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/util/spring-util.xsd">

  • ==使用util标签完成list集合注入提取 ==

  • <util:list id="booklist">
        <value>java</value>
        <value>c++</value>
        <value>python</value>
    </util:list>
    <bean id="book" class="org.pojo.Book">
        <property name="bname" ref="booklist"></property>
    </bean>
</beans>

IOC操作Bean管理（FactoryBean）

==*==Spring有两种类型bean，一种普通bean ，另外一种工厂bean（FactoryBean）

  • 普通bean：在配置文件中定义bean类型就是返回类型
  • 工厂bean：在配置文件定义bean类型可以和返回类型不一样

1.第一步，创建类，让这个类作为工厂bean，实现接口FactoryBean

2.实现接口里面的方法，在实现的方法中定义返回的bean类型

IOC操作Bean管理（bean的作用域）

*		 在Spring里面，设置创建 bean实例是单实例还是多实例
*		 在Spring里面，默认情况下，bean是单实例对象

==*==如何设置单实例还是多实例

  • 在Spring配置文件中bean标签里面有属性((scope)用于设置单实例还是多实例

  • scope属性值

    • 第一个值，默认值：singleton，表示是单实例对象

    • 第二个值，prototype，表示多实例对象

    • <bean id="book" class="org.pojo.Book" scope="prototype">
    <property name="bname" ref="booklist"></property>
</bean>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-blz0ZcAc-1648795550805)(C:\Users\D\AppData\Roaming\Typora\typora-user-images\image-20220323143849176.png)]

  • singleton和prototype的区别
    • singleton是单实例，prototype是多实例
    • 设置scope值是singleton时候，加载Spring配置文件时候就会创建单实例对象
    • 设置scope值是prototype时候，不是在加载spring配置文件时候创建对象，在调用getBean方法时候创建多实例对象

说明了解

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

  • 生命周期
    • 从对象创建到对象销毁的工程
  • bean生命周期
    • 通过构造器创建bean实例（无参数构造）
    • 为bean的属性设置值和对其他bean引用（调用set方法）
    • 调用bean的初始化的方法（需要进行配置初始化的方法）
    • bean可以使用了（对象获取到了）
    • 当容器关闭时候，调用bean的销毁的方法（需要进行配置销毁的方法
  • 演示bean的生命周期
public class Order {
    private String oname;
    public String getOname() {
        return oname;
    }
    public Order() {
        System.out.println("第一步，执行了无参数构造创建bean实例");
    }
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步，执行set方法设置属性值");
    }
    public void initMethod(){
        System.out.println("第三步，执行初始化方法");
    }
    public void destoryMethod(){
        System.out.println("第五步，执行销毁方法");
    }

<bean id="order" class="org.pojo.bean.Order" init-method="initMethod" destroy-method="destoryMethod">
    <property name="oname" value="姓名"></property>
</bean>

@Test
public void testbeans(){
    ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("bean3.xml");
    Order order=context.getBean("order",Order.class);
    System.out.println("第四步，获取到对象");
    System.out.println(order.getOname());
    context.close();
}

第一步，执行了无参数构造创建bean实例
第二步，执行set方法设置属性值
第三步，执行初始化方法
第四步，获取到对象
姓名
第五步，执行销毁方法

  • bean的后置处理器，bean的生命周期有七步
    • 通过构造器创建bean实例（无参数构造）
    • 为bean的属性设置值和对其他bean引用（调用set方法）
    • 把bean实例传递bean后置处理器的方法
    • 调用bean的初始化的方法（需要进行配置初始化的方法）
    • 把bean实例传递bean后置处理器的方法
    • bean可以使用了（对象获取到了）
    • 当容器关闭时候，调用bean的销毁的方法（需要进行配置销毁的方法

添加后置处理器

  • 创建类，实现接口BeanPostProcessor，创建后置处理器，实现方法

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

  • 什么是自动装配

    • 根据指定装配规则（属性名或者属性类型），Spring自动将匹配的属性值进行注入

  • 演示自动装配过程

    • byName（属性名）byType（属性类型）

    •    ```

IOC操作Bean管理（外部属性文件）

  • 引入外部属性文件配置数据库连接池
  • 创建外部属性文件，properties格式文件，写数据库信息
  • 把外部properties属性文件引入到spring配置文件中
    • 引入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">

在 spring配置文件使用标签引入外部属性文件

<context:property-placeholder location="classpath:jdbc.properties"/>

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

1.什么是注解

  • 注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值…）
  • 使用注解，注解作用在类上面，方法上面，属性上面。
  • 使用注解目的，简化xml配置

2.Spring针对Bean管理中创建对象提供注解

  • @Component

  • @Service

  • @Controller

  • @Repository

    *上面四个注解功能都是一样的，都可以用来创建bean实例

3.基于注解方式 实现对象创建

  • 第一步，引入依赖

    • spring-aop的依赖

  • 第二步，开启组件扫描。

    • <?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/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">

<!--    组件扫描-->
    <context:component-scan base-package="com.dhy.pojo"></context:component-scan>
</beans>

  • 第三步，创建类，在类的上面添加对象注解

  • //在注解里面value属性值可以省略不写
//默认值是类名称，首字母小写

  • 开启组件扫描的细节配置

4.基于注解方式实现属性注入

  • @AutoWired（Spring包）

    • 根据属性类型进行自动装配
      • 第一步把service和dao对象创建，在service和dao类添加创建对象注解
      • 第二步在service注入dao对象，在service类添加dao类型属性，在属性上面使用注解。

  • @Qualifier（Spring包）

    • 根据属性名称进行注入
      • 这个@Qualifier注解的使用，和上面的@AutoWired一起使用

  • @Resource（javax包中扩展包）

    • 可以根据类型注入，可以根据名称注入

    • //@Resource//根据类型注入
@Resource（name="userDaoImol"）//根据名称进行注入
private UserDao userDao

  • @Value

    • 注入普通类型属性
@Value(value="abc")
private String name;

完全注解开发

​ 1.创建配置类，替代 xml配置文件

@Configuration //作为配置类替代xml文件
@ComponentScan(basePackages ={"com.dhy"})
public class SpringConfig {
}

@Test
public void test2() {
    ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    Student student = context.getBean("student", Student.class);
    System.out.println(student);
    student.test();


}

AOP(概念)

  1. 什么是AOP：

    • 面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率* *

    • 通俗描述：不通过修改源代码方式，在主干功能里面添加新功能。

Aop底层原理

​ 1.有两种情况代理

  • 第一种 有接口情况，使用JDK动态代理
    • 创建接口实现类代理对象，增强类的方法。
  • 第二种没有接口情况，使用CGLIB动态代理
    • 创建子类的代理对象，增强类的方法

​

AOP（JDK动态代理）

  1. 使用JDk动态代理，使用Proxy类里面的方法创建代理对象。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SqrAb9re-1648795550807)(C:\Users\D\AppData\Roaming\Typora\typora-user-images\image-20220324073327718.png)]

    2.调用newProxyInstance方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eErNWgae-1648795550808)(C:\Users\D\AppData\Roaming\Typora\typora-user-images\image-20220324073513571.png)]

方法有三个参数：

  • 第一个参数：类加载器。
  • 第二参数：增强方法所在的类，这个类实现的接口，支持多个接口。
  • 第三参数：实现这个接口InvocationHandler创建代理对象，写增强的方法。

  1. 编写JDK动态代理代码

    • 1.创建接口，定义方法。

    • public interface UserDao {
    public int add(int a,int b);
    public String update(String a);
}

    • 2.创建接口实现类，实现方法。

    • public class UserDaoImpl implements UserDao {
    @Override
    public int add(int a, int b) {
        return a+b;
    }
    @Override
    public String update(String  a) {
        return a;
    }
}

    • 3.使用Proxy类创建接口代理对象。

    • package com.dhy;
import com.dhy.dao.UserDao;
import com.dhy.dao.impl.UserDaoImpl;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
public class JdkProxy {
    public static void main(String[] args) {
        Class[] interfaces={UserDao.class};
        UserDao userDao=new UserDaoImpl();
   UserDao dao= (UserDao) Proxy.newProxyInstance(JdkProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
   int result=dao.add(1,5);
        System.out.println(result);

    }}
    
    class UserDaoProxy implements InvocationHandler{
        //把创建的是谁的代理对象，把谁传递过来
        //有参构造传递
        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;
        }
    }

AOP（术语）

  • 连接点：
    • 类里面哪些方法可以被增强，这些方法称为连接点。
  • 切入点
    • 实际被真正增强的方法，称为切入点。
  • 通知（增强）
    • 实际增强的逻辑部分称为通知
    • 通知五种类型
      • 前置通知
      • 后置通知
      • 环绕通知
      • 异常通知
      • 最终通知
  • 切面
    • 是动作
    • 把通知应用到切入点过程。

AOP操作（准备）

  • 1.Spring框架一般都是基于AspectJ实现AOP操作
    • 什么是AspectJ
      • AspectJ不是Spring组成部分，独立的AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作。
    • 基于AspectJ实现AOP操作
      • 基于xml配置文件实现
      • 基于注解方式实现（使用）
  • 在项目工程里面引入AOP依赖
<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.2.15.RELEASE</version>
</dependency>

  • 切入点表达式

    • 切入点表达式作用：知道对哪个类里面的哪个方法进行增强。

    • 语法结构：

      • execution([权限修饰符] [返回类型] [类全路径] [方法名称] ([参数名称]))

        举例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..(…))

AOP操作（AspectJ注解）

  1. 创建类，在类里面定义方法。

    //被增强类
@Component
public class User {
    public void test1(){
        System.out.println("User方法执行。。。。。");
    }
}

  2. 创建增强类（编写增强逻辑）

    • 在增强类里面，创建方法，让不同的方法代表不同的通知类型

    • //增强类
@Component
@Aspect
public class UserProxy {
    @Before(value = "execution(* com.dhy.service.User.test1(..))")
    public void before() {
        System.out.println("方法之前执行。。。");
    }
}

  3. 进行通知的配置

    • 1在Spring配置文件中，开启注解扫描。

      <?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.dhy.service"></context:component-scan>
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    • 使用注解创建User和UserProxy对象

    • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GpvUF3qn-1648795550808)(C:\Users\D\AppData\Roaming\Typora\typora-user-images\image-20220324134746841.png)]

    • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kv7WVXxf-1648795550809)(C:\Users\D\AppData\Roaming\Typora\typora-user-images\image-20220324134713879.png)]

    • 在增强类上面添加注解@Aspect

    • 在Spring配置文件中开启生成代理对象```

          <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

  4. 配置不同类型的通知

    1. 在增强类的里面，在作为通知方法上面添加类型注解，使用切入点表达式配置
public class UserProxy {
	//前置通知
    @Before(value = "execution(* com.dhy.service.User.test1(..))")
    public void before() {
        System.out.println("方法之前执行。。。");
    }
    //最终通知有异常也执行
    @After(value = "execution(* com.dhy.service.User.test1(..))")
    public void after() {
        System.out.println("After方法执行。。。");
    }
    //后置通知（返回通知）有异常不执行
    @AfterReturning(value = "execution(* com.dhy.service.User.test1(..))")
    public void afterReturning() {
        System.out.println("AfterReturning。。。");
    }
    //异常通知
    @AfterThrowing(value = "execution(* com.dhy.service.User.test1(..))")
    public void afterThrowing() {
        System.out.println("AfterThrowing。。。");
    }
    //环绕通知
    @Around(value = "execution(* com.dhy.service.User.test1(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知之前。。。");
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知之后。。。。");
    }
}

5.相同切入点抽取

  • @Pointcut(value = "execution(* com.dhy.service.User.test1(..))")
 public void pointdemo(){}

@Before(value = "pointdemo()")
 public void before() {
     System.out.println("方法之前执行。。。");
 }

6.有多个增强类对同一个方法进行增强，设置增强类优先级

  • 在增强类上面添加注解@Order（数字类型值），数组类型值越小优先级越高（从0开始）
@Component
@Aspect
@Order(10)
public class PerosnProxy {

AOp操作（AspectJ配置文件）

<bean id="book" class="com.dhy.service.Book"></bean>
<bean id="bookproxy" class="com.dhy.service.BookProxy"></bean>

<!--配置AOP增强-->
<aop:config>
    <!--切入点-->
    <aop:pointcut id="p" expression="execution(* com.dhy.service.Book.addbook(..))"/>
    <!--配置切面-->
    <aop:aspect ref="bookproxy">
        <!--增强方法具体作用在某个方法上-->
                <aop:before method="before" pointcut-ref="p"></aop:before>
    </aop:aspect>
</aop:config>

完全使用注解开发

  • @Configuration//表示配置类
@ComponentScan(basePackages = {"com.dhy"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}

JdbcTemplate（概念和装备）

什么是jdbctemplate

  • Spring框架对JDBC进行封装，使用jdbcTemplate方便实现对数据库的操作

配置jdbcTemplate对象

  • 1.引入相关依赖

  • img

  • 在Spring配置文件中配置数据库连接对象

  • bean.xml

  • <!-- 配置 druid 数据库连接池 -->
<!-- 加载 druid 配置文件 -->
<context:property-placeholder location="classpath:druid.properties"/>
<!-- 创建数据库连接池对象 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
	<property name="driverClassName" value="${druid.driverClassName}"></property>
	<property name="url" value="${druid.url}"></property>
	<property name="username" value="${druid.username}"></property>
	<property name="password" value="${druid.password}"></property>
</bean>

  • druid.properties

  • druid.driverClassName=com.mysql.cj.jdbc.Driver
druid.url=jdbc:mysql://localhost:3306/book_spring?serverTimezone=UTC&rewriteBatchedStatements=true
druid.username=root
druid.password=密码

  • 配置jdbcTemplate对象，并为dataSource属性注入到数据库连接池对象

  • <!-- 创建 JdbcTemplate 对象，并将数据库连接池对象注入到 JdbcTemplate 对象的 dataSource 属性中 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	<property name="dataSource" ref="dataSource"></property>
</bean>

  • 开启组件扫描

  • <!-- 开启组件扫描，创建使用注解生成的对象 -->
<context:component-scan base-package="com.mcc.spring5Jdbc"></context:component-scan>

  • 创建对应的类并使用注创建对象，这里以 BookDAO.java，BookDAOImpl.java，BookService.java 为例
    BookDAO.java

  • package com.mcc.spring5Jdbc.dao;

public interface BookDAO {

}


  • package com.mcc.spring5Jdbc.dao;

@Repository
public class BookDAOImpl implements BookDAO{
	@Autowired//配置文件中已经创建该对象
	private JdbcTemplate jdbcTemplate;

}


  • package com.mcc.spring5Jdbc.service;

@Service
public class BookService {
	@Autowired//注入 BookDAOImpl 对象
	private BookDAO bookDAO;

}

  • JdbcTemplate 操作

方法作用
**update(String sql，Object… args)添加、修改、删除
**queryForObject(String sql，Class requiredType)查询某个值
queryForObject(String sql，RowMapper rowMapper，Object… args)** 查询某个对象
query(String sql，RowMapper rowMapper，Object… args)** 查询某个集合**
batchUpdate(String sql，List<Object[]> batchArgs)批量添加、修改、删除

事物概念

  • 上面是事务

    • 事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败。

  • 经典场景

    • 银行转账

  • 事务四个特性（ACID）

    • 原子性
    • 一致性
    • 隔离性
    • 持久性

    事务操作过程：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qx6Blwsf-1648795550810)(C:\Users\D\AppData\Roaming\Typora\typora-user-images\image-20220325121324407.png)]

  • 事务操作（Spring事务管理介绍）

    • 事务添加到javaEE三层结构里面Service层（业务逻辑层）

    • 在Spring进行事务管理操作

      • 有两种方式：编程式事务管理和声明事务管理（使用）

    • 声明式事务管理

      • 基于注解方式
      • 基于xml配置文件方式

    • 在Spring进行声明式事务管理，底层使用AOP原理。

    • Spring事务管理API

      • 提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类
      • img

      Spring 提供 PlatformTransactionManager 接口，实现对事务的管理操作，对于不同的框架，提供不同的实现类，如：不整合其他外部框架时，使用 DataSourceTransactionManager 实现类；整合 MyBatis 框架时，使用 DataSourceTransactionManager 实现类。

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

    • 在Spring配置文件配置事务管理器

    • <!-- 1.创建事务管理器对象 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 注入与JdbcTemplate相同的数据库连接池对象 -->
		<property name="dataSource" ref="dataSource"></property>
	</bean>

    • 在Spring配置文件中，开启事务注解（在Spring配置文件中引入名称空间tx）

    • <!-- 使用 tx（事务）名称空间 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

    • 在要添加事务的类或方法上添加@Transactional注解

    • @Transactional
public class UserService {
}

    • 注意：@Transactional 注解可以添加在类上面，也可以添加在方法上面
      （1）若添加在类上面，表示为这个类内所有的方法都添加事务
      （2）若添加在方法上面，表示为这个方法添加事务

  • 事务操作（声明式事务管理参数配置）、

    • 在service类上面添加==@Transactional==,在这个注解里面可以配置事务相关参数
    • propagation:事务传播行为
      • 多事务方法直接进行调用，这个过程事务是如何进行管理的
      • img
      • REQUIRED：如果 A 方法有事务，调用 B 方法后，B 使用 A 的事务；如果 A 方法没有事务，调用 B 方法之后，开启一个新的事务。
      • REQUIRED_NEW：不论 A 方法有无事务，调用 B 方法后，都开启一个新的事务。
    • ioslation:事务隔离级别
      • 事务有个特性称为隔离性，多事务操作之间不会产生影响，不考虑隔离性会产生很多问题
      • 有三个读的问题：脏读，不可重复读，幻读
      • 脏读：一个未提交事务读取到另一个未提交事务的数据
      • 不可重复读：一个未提交事务读取到另一提交事务修改的数据。
      • 虚读：一个未提交事务读取到另一提交事务添加的数据。
      • 解决：通过设置事务隔离级别，解决读问题（MySQL 默认使用 REPEATABLE_READ）
      • img
    • timeout：超时时间
      • 事务需要在一定时间类进行提交，如果不提交进行回滚
      • 默认值是-1，设置时间以秒进行计算。
    • readOnly：是否只读
      • 读：查询操作。 写：添加修改删除操作
      • readOnly默认值是false，表示可以查询，可以添加修改删除操作。
      • 设置为true，只能查询。
    • rollbackFor：回滚
      • 设置出现那些异常进行事务回滚。
    • noRollbackFor：不回滚
      • 设置出现那些异常不进行事务回滚。

  • 事务操作（xml声明式事务管理）

    • 在 spring 配置文件中进行配置：
      （1）配置事务管理器
      （2）配置事务通知<tx:advice id=""></tx:advice>
      （3）配置切入点和切面<aop:config></aop:config>

    • <?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"
	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
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
	
	<!-- 加载 数据库连接池配置文件 -->
	<context:property-placeholder location="classpath:druid2.property"/>
	<!-- 创建 数据库连接池对象 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
		<!-- 注入属性 -->
		<property name="driverClassName" value="${druid.driverClassName}"></property>
		<property name="url" value="${druid.url}"></property>
		<property name="username" value="${druid.username}"></property>
		<property name="password" value="${druid.password}"></property>
	</bean>
	
	<!-- 创建 JdbcTemplate 对象 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 开启组件扫描，用注解创建对象以及注入属性 -->
	<context:component-scan base-package="com.mcc.spring5.jdbc.transaction"></context:component-scan>
	
	<!-- 进行事务操作 -->
	<!-- 1.创建事务管理器对象 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 注入与JdbcTemplate相同的数据库连接池对象 -->
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 2.配置事务通知 -->
	<tx:advice id="txAdvice">
		<!-- 配置事务参数 -->
		<tx:attributes>
			<!-- 为何种方法添加事务操作 -->
			<tx:method name="accountMoney" propagation="REQUIRED"/><!-- name="account*" 表示所有以account开始的方法 -->
		</tx:attributes>
	</tx:advice>
	<!-- 3.配置切入点和切面 -->
	<aop:config>
		<!-- 配置切入点 -->
		<aop:pointcut expression="execution(* com.mcc.spring5.jdbc.transaction.UserService.*(..))" id="pointcut"/>
		<!-- 配置切面，注意：使用的是专门用于配置事务的切面标签 -->
		<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
	</aop:config>
	
</beans>

完全注解声明式事务管理

使用 配置类 代替 xml 配置文件.

  • @Bean：使用在方法上，在加载配置类时，自动执行该方法，获取返回值对象，保存到 IOC 容器中。
    如何保证使用的是同一个数据库连接池对象？*

  • 将 DataSource 对象以参数形式传入到其他方法中，保证使用的是同一个数据库连接池对象。
    原因：在加载配置类时，由于 @Bean 注解的作用，会自动调用方法，因为方法的形参为 DataSource 对象，Spring 会自动在 IOC 容器中寻找 DataSource 对象，并传入方法中。

    package com.mcc.spring5.jdbc.transaction.config;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import com.alibaba.druid.pool.DruidDataSource;

//Spring配置类
@Configuration//声明配置类
@EnableTransactionManagement//开启事务注解
@ComponentScan(basePackages = {"com.mcc.spring5.jdbc.transaction"})//开启组件扫描
public class TxConfig {
	//创建数据库连接池对象
	@Bean
	public DruidDataSource getDruidDataSource() {
		//加载配置文件
		Properties prop = new Properties();
		InputStream inputStream = TxConfig.class.getClassLoader().getResourceAsStream("druid2.property");
		try {
			prop.load(inputStream);
		} catch (IOException e) {
			throw new RuntimeException("Error load file named druid2.property");
		}
		//创建druid对象
		DruidDataSource dataSource = new DruidDataSource();
		dataSource.setDriverClassName(prop.getProperty("druid.driverClassName"));
		dataSource.setUrl(prop.getProperty("druid.url"));
		dataSource.setUsername(prop.getProperty("druid.username"));
		dataSource.setPassword(prop.getProperty("druid.password"));
		return dataSource;
	}
	//创建JdbcTemplate对象
	@Bean
	public JdbcTemplate getJdbcTemplate(DruidDataSource dataSource) {
		JdbcTemplate jdbcTemplate = new JdbcTemplate();
		jdbcTemplate.setDataSource(dataSource);
		return jdbcTemplate;
	}
	//创建事务管理器对象
	@Bean
	public DataSourceTransactionManager getDataSourceTransactionManager(DruidDataSource dataSource) {
		DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
		transactionManager.setDataSource(dataSource);
		return transactionManager;
	}
}


@Test
public void testConfig() {
	AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TxConfig.class);
	UserService userService = context.getBean("userService", UserService.class);
	userService.accountMoney();
	context.close();
}

Spring5框架新功能

  • spirng框架整合Log4j2

    • 第一步引入jar包

    • img

      • <!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-api -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.13.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.13.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-slf4j-impl -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j-impl</artifactId>
    <version>2.13.1</version>
    <scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.36</version>
</dependency>

      • 创建 Log4j 配置文件
        注意：名称必须为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>

st



org.slf4j
slf4j-api
1.7.36

   ```

 * 

 * 创建 Log4j 配置文件
   注意：名称必须为`log4j2.xml`

 * ```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>
   
   ```

 *
iume
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring框架 概述
08-07
NULL 博文链接：https://tian602564031.iteye.com/blog/2122815
什么是Spring框架？
weixin_46529694的博客
07-05 1237
java全站知识点
【框架学习】spring简介
小鼠标的博客
03-17 2603
Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。 Spring 作为一个解决企业复杂度的框架，在Java开发中享有圣喻，号称所有java开发均可使用此框架，对于其他框架（如，Struts，Hibernate，Mybits等）都很好的支持。Spring作为项目的
Spring框架介绍
支持向量机学习笔记
02-28 682
Spring 框架是一个分层的、面向切面的 Java 应用程序的一站式轻量级解决方案，它是 Spring 技术栈的核心和基础，是为了解决企业级应用开发的复杂性而创建的。
spring框架--全面详解（学习笔记）
swy2560666141的博客
02-26 8841
由 Spring IoC 容器管理的对象称为 Bean，Bean 根据 Spring 配置文件中的信息创建。可以把 Spring IoC 容器看作是一个大工厂，Bean 相当于工厂的产品，如果希望这个大工厂生产和管理 Bean，则需要告诉容器需要哪些 Bean，以及需要哪种方式装配 Bean。Spring 配置文件支持两种格式，即 XML 文件格式和 Properties 文件格式。
Spring框架
m0_51457307的博客
11-20 1万+
一、Spring概述 Spring 是目前主流的 Java Web 开发框架，是 Java 世界最为成功的框架。该框架是一个轻量级的开源框架，具有很高的凝聚力#%E4%B8%80%E3%80%81Spring%E6%A6%82%E8%BF%B0和吸引力。
第一部分：Spring框架概述1
08-03
第一部分：Spring框架概述Part I. Overview of Spring FrameworkThe Spring Framework is a lig
简述Spring框架（一）
12-21
Spring是分层的Java SE/EE应用full-stack轻量级开源框架，以IOC（Inverse Of Control：控制反转）和AOP（Aspect Oriented Programmaing：面向切面编程）为内核，提供了展现层Spring MVC和持久层Spring JDBC以及业务...
深入解析Java Spring框架
最新发布
03-04
Java Spring框架作为企业级应用的首选框架之一，承载着广泛的开发任务。本文将全方位探讨Java Spring框架，包括基本介绍、个人心得、实际项目经验分享以及相关深度练习。 一、Java Spring框架介绍 1.1 概述 Java ...
Spring框架1
08-04
1.Spring概述 3.编写配置文件注册bean 4.代码测试 1.Spring的配置文件名常用applicationContext.xml 2.Bean在创
Spring框架是什么？（最全）
SeniorShen的博客
10-21 1281
Spring框架 一：Spring是什么？ Spring 是一个轻量级的开源框架。 Spring 是一个IOC(DI)和AOP的容器框架。 二：Spring作用是什么？ Spring主要对javaBean的生命周期进行集中的管理。 三：Spring优点是什么？ Spring可以集中管理对象。 Spring通过控制反转，可以实现松散耦合。 Spring提供了一个持续的事物管理入口，可以管理...
Spring框架(一)：spring框架的简介
yu1755128147的博客
12-13 3102
一、spring框架的概念 Spring是一个开源轻量级的控制反转(IoC)和面向切面(AOP)的容器框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 二、sp...
Java Spring框架介绍，5分钟一看就会
qq_50838572的博客
02-19 2131
spring框架
Spring框架详解
秦矜のblog
09-10 2321
Spring框架详解
Spring-全面详解（基础知识）
热门推荐
m0_63324772的博客
03-24 2万+
Spring-全面详解（基础知识）入门级 持续更新中 Spring5框架 内容介绍： 1.Spring概念 2.IOC容器 3.Aop 4.JDBCTEmplate 5.事物管理 6.Spring5新特性
面向过程编程，面向对象编程和面向切面编程理解
小鼠标的博客
03-17 6981
面向过程(Procedure Oriented)是一种以过程为中心的编程思想。这些都是以什么正在发生为主要目标进行编程，不同于面向对象的是谁在受影响。与面向对象明显的不同就是封装、继承、类。面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP 达到
spring框架
weixin_30555125的博客
09-28 113
1.什么是spring框架？ 　　Spring 是一个开源框架，是一种整合性的框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。至03年spring框架发布以来到现在spring框架已经发展成JavaEE开发中的非常重要的一个框架。虽然还是有公司采用自己的方式来处理代码间的耦合问题，但...
Spring Security 框架概述
06-01
Spring Security是一个基于Spring框架的安全框架，提供了一套完整的安全认证和访问控制的解决方案，可以用于保护Web应用、REST API、方法调用等资源。Spring Security的主要功能包括： 1. 身份认证：支持多种身份...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值