spring框架教程

已于 2022-11-17 20:42:38 修改
阅读量324 收藏 2
点赞数 1
分类专栏： SSM 文章标签： spring
于 2022-10-26 16:45:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_strive/article/details/127535535
版权

Spring框架

一、spring简介

简介：spring框架是一个轻量级的控制反转和面向切面的容器框架，用来解决项目开发中的复杂度问题–解耦

轻量级：体积小，对代码没有侵入性（代码侵入性：指的是业务代码中不会调用spring中任何一个类）
控制反转：IoC（Inverse of contral），把对象创建的工作交给spring完成，并且他还可以给对象属性赋值。
面向切面：AOP（Aspect Oriented Programming）面向切面编程，可以在不改变原有业务逻辑的情况下实现对业务逻辑的增强
容器：实例的容器，管理创建的对象

图片显示的就是spring家族 这篇文章最主要介绍Core Container这里边的组件也是最核心的组件
Web组件也就是我们常说的SpringMVC框架
Test组件是spring提供的测试框架
Data组件是spring对jdbc的封装，相当于mybatis框架。但是我们这里只使用他的transctions组件即事务
先介绍spring最核心的功能IoC和Aop

二、SpringIoC

一、Spring框架部署（IoC）
1.1、创建Maven工程
		创建这两个工程都可以.我创建java工程
  • java
  • web
1.1.2、添加springIoC依赖
  • core
  • beans
  • aop
  • expression
  • context

注意：正常情况下这5个依赖是都要导入的，但是他们5个是互相依赖的所以导入一个就行，maven会自动导入其他的依赖。

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.22.RELEASE</version>
</dependency>
1.1.3、创建Spring配置文件

通过配置文件告诉Spring容器创建什么对象，给对象属性赋什么值

在rescources目录下创建applicationContext.xml文件（注意名字是可以随便起的，大家都用这个名所以我也用）
聪明的人会把下面代码存成模板

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

</beans>
1.2、创建Student实体类
public class Student {
    private String stuName;
    private Integer stuAge;
    private String stuGender;

    @Override
    public String toString() {
        return "Student{" +
                "stuName='" + stuName + '\'' +
                ", stuAge=" + stuAge +
                ", stuGender='" + stuGender + '\'' +
                '}';
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public Integer getStuAge() {
        return stuAge;
    }

    public void setStuAge(Integer stuAge) {
        this.stuAge = stuAge;
    }

    public String getStuGender() {
        return stuGender;
    }

    public void setStuGender(String stuGender) {
        this.stuGender = stuGender;
    }
}

配置配置文件

<bean id="Student" class="com.xxp.bean.Student">
	<property name="stuName" value="张三"/>
	<property name="stuGender" value="男"/>
	<property name="stuAge" value="25"/>
</bean>

写测试类（这里你会发现你已经没有在new出Student啦 直接从spring容器中获取）

public class StudentTest {
    public static void main(String[]args){
        //这个就是创建spring容器的对象
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //从spring容器中获取Student对象 注意：这里的参数是配置文件中的id
        Object student = context.getBean("Student");
        System.out.println(student);
    }
}
二、spring的IoC和DI

IoC控制反转，依赖Spring对象工厂完成对象的创建
DI依赖注入，对创建好的对象的属性赋值

2.1、DI依赖注入
2.1.1、三种方式

spring容器通过反射给类创建对象，并给对象赋值
通过反射，给对象赋值的方式有3种：

  • set方式注入
  • 构造器注入
  • 接口注入（不常用）
2.1.1.1、set注入

使用到的实体类：

/**
 * 书类
 * @author xxp
 */
@Getter
@Setter
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class Book {
    private Integer bookId;
    private String bookName;
}



/**
 * Student实体类
 * @author xxp
 */
@Getter
@Setter
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private String stuName;
    private Integer stuAge;
    private String stuGender;
    private Book book;
    private List<Book> course;
    private Set<String> achievement;
    private Map<String ,String> testMap;
}

一、基本类型可以通过<property标签直接注入

<bean id="Student" class="com.xxp.bean.Student">
	<property name="stuName" value="张三"/>
	<property name="stuGender" value="男"/>
	<property name="stuAge" value="25"/>
	
	
</bean>

二、对象类型有两种方式

  • 第一种：先把对象交给spring容器 然后引入
	<bean id="book" class="com.xxp.bean.Book">
		<property name="bookId" value="01"/>
		<property name="bookName" value="java"/>
	</bean>
	<bean id="Student" class="com.xxp.bean.Student">
		<property name="book" ref="book"/>
	</bean>
  • 第二种方式：
<bean id="Student" class="com.xxp.bean.Student">
	<property name="book">
		<bean class="com.xxp.bean.Book">
			<property name="bookId" value="01"/>
			<property name="bookName" value="java"/>
		</bean>
	</property>
</bean>

三、List类型：使用list标签
基本类型赋值：

  • 第一种方式：
<bean id="Student" class="com.xxp.bean.Student">
	<property name="course">
		<list>
			<value>1</value>
			<value>2</value>
		</list>
	</property>
</bean>

第二种方式：

	<property name="course" value="1,2,3"/>

对象类型赋值：

  • 第一种方式：
<bean id="Student" class="com.xxp.bean.Student">

	<property name="course">
		<list>
			<bean class="com.xxp.bean.Book">
				<property name="bookId" value="01"/>
			</bean>
			<bean class="com.xxp.bean.Book">
				<property name="bookId" value="02"/>
				<property name="bookName" value="mysql"/>
			</bean>
		</list>
	</property>

</bean>
  • 第二种方式：
	<bean id="book" class="com.xxp.bean.Book"></bean>
<bean id="Student" class="com.xxp.bean.Student">
	<property name="course">
		<list>
			<ref bean="book"></ref>
			<ref bean="book"></ref>
		</list>
	</property>

</bean>

</beans>
四、set类型：与list一致
五、map类型：
<property name="testMap">
		<map>
			<entry key="a" value="1"/>
			<entry key="b" value="2"/>
		</map>
	</property>
2.1.1.2、构造器注入

基本数据类型可以使用下面方式注入 index是参数的顺序下标，可以不要这个index，但是必须保证参数列表的顺序是正确的

	<bean id="Student" class="com.xxp.bean.Student">
		<constructor-arg index="0" value="张三"/>
		<constructor-arg index="1" value="22"/>
		<constructor-arg index="2" value="男"/>
	</bean>

对于集合类型采用下面方式注入

<bean id="Student" class="com.xxp.bean.Student">
		<constructor-arg index="0" value="张三"/>
		<constructor-arg index="1" value="22"/>
		<constructor-arg index="2" value="男"/>
		<constructor-arg index="3">
			<bean class="com.xxp.bean.Book"></bean>
		</constructor-arg>

		<constructor-arg index="4">
			<list>
				<bean class="com.xxp.bean.Book"></bean>
				<bean class="com.xxp.bean.Book"></bean>
			</list>
		</constructor-arg>
		<constructor-arg index="5">
			<set>
				<value>1</value>
				<value>2</value>
			</set>
		</constructor-arg>
	</bean>
三、Spring-IoC----Bean的作用域

在spring中bean默认是单例模式，bean标签中设置scope=“singleton” 表示该对象为单例模式
如果想使用非单例模式则将值改为scope=“prototype”
spring中默认是饿汉模式spring容器在初始化的时候就会完成对象创建，在bean标签中设置**lazy-init=“true”**则表示开启懒汉模式

3.1、bean声明周期方法

在bean标签中通过init-method="init"配置当前类的初始化方法（该方法在对象创建之后执行）
使用destroy-method="destroy"来配置当前类的销毁方法（该方法在对象销毁之前执行）

配置文件

	<bean id="book" class="com.xxp.bean.Book" scope="prototype" init-method="init" destroy-method="destroy"></bean>

实体类

@Getter
@Setter
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class Book {
    private Integer bookId;
    private String bookName;

    public void init(){
        System.out.println("对象创建后执行");
    }
    public void destroy(){
        System.out.println("对象销毁前调用");
    }
}
四、Spring-IoC----自动装配

spring可以在实例化bean的时候，从spring容器中找到匹配的实例赋值给当前bean的属性
自动装配有两种方式：
第一种：byName 通过id名装配 缺点：如果id名字一致，但是类型不一致就会装配失败然后抛出异常
第二种：byType 通过类型装配 缺点：如果有多个类型一致的话就会抛出异常

第一种方式：配置autowire=“byName”

<bean id="student" class="com.xxp.bean.Student" autowire="byName"></bean>

第二种方式：配置autowire=“byType”

<bean id="student" class="com.xxp.bean.Student" autowire="byType"></bean>
五、Spring-IoC----注解配置

前面我们可以通过使用xml配置文件的方式将类声明给spring容器管理，从而让spring容器实现对象的创建和属性赋值
我们还可以通过注解的方式将我们的实体类交给spring容器管理，从而简化开发。

5.1、项目部署

5.1.1、引入依赖

  <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.22.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
    </dependencies>

5.1.2、创建实体类

package com.xxp.bean;

import lombok.*;

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
@Setter
@Getter
public class Student {
    private String name;
    private Integer age;
    private String sex;
}

5.1.3、创建配置文件

在配置文件中需要使用context:annotation-config/来声明使用注解配置
并且要通过<context:component-scan base-package=“com.xxp.bean”/>来告诉spring工厂注解的扫描范围，从而让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"
        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:annotation-config/>
	<!--声明Spring工厂注解的扫描范围-->
	<context:component-scan base-package="com.xxp.bean"/>
</beans>
六、Spring-IoC----常用注解（注解编程）
6.1.1、@component注解
  • 类注解，声明此类被spirng容器管理，相当于bean标签 @component（value=“类名”）相当于bean标签的id属性，也可以不写默认是类名的首字母小写
  • 除了@component注解外还有 @Service @Controller@Repository这三个注解也可将类声明到spring容器中，他们主要就是语义上的区别（也就是用的地方不一样）
    1.@Service主要用在业务层，比如Service接口的实现类
    2.@Controller主要用在控制层，比如servlet
    3.@Repository主要用在持久层，比如Dao接口
    4.@component主要用在上述中的其他类

实体类

@Component(value = "student")
public class Student {
    private String name;
    private Integer age;
    private String sex;
}
6.1.2、@Scope注解

类注解，在实体类上加上@Scope注解来声明，对象为单例还是多例

单例模式

@Scope(value = "singleton")
public class Student {
    private String name;
    private Integer age;
    private String sex;
}

多例模式

@Scope(value = "prototype")
public class Student {
    private String name;
    private Integer age;
    private String sex;
}
6.1.3、@Lazy注解

类注解，开启饿汉模式或者懒汉模式

@Lazy(value = true)
public class Student {
    private String name;
    private Integer age;
    private String sex;
}
6.1.4、@PostConstruct和 @PreDestroy注解

方法注解，@PostConstruct表示在创建对象之后执行
方法注解， @PreDestroy表示在对象销毁之前执行

	 @PostConstruct
    public void init(){
        System.out.println("初始化方法");
    }
    @PreDestroy
    public void destroy(){
        System.out.println("销毁方法");
    }

6.1.5、@Autowired注解和@Resource注解

属性注解、方法注解，@Autowired注解用于spring在创建对象的时候对对象的属性进行初始化操作
默认是使用的byType根据类型赋值，如果类型不匹配就会报错，可以使用它的required = false属性设置如果类型不匹配就设置当前属性值为null
要是想使用byName类型进行赋值，可以在set方法参数处加上@Qualifier注解

public class Student {
    private String name;
    private Integer age;
    private String sex;
    @Autowired(required = false)
    private Book book;
}

byName类型

public class Student {
    private String name;
    private Integer age;
    private String sex;
    
    private Book book;
    @Autowired(required = false)
	public void setBook(@Qualifier Book book){
	this.book=book;
}
	
}

@Resource注解 也是自动装配属性，它是java注解包提供的，并不是spring提供的，它默认是byName如果byName找不到那么会byType，如果根据类型也找不到那么就会抛出异常

public class Student {
    private String name;
    private Integer age;
    private String sex;
    
    private Book book;
   @Resource(required = false)
	public void setBook(@Qualifier Book book){
	this.book=book;
}
	
}

三、SpringAOP

先学习一下代理模式，代理模式比较抽象，可以选择暂时跳过这一部分，理论上不会影响SpringAOP的学习，当然学会啦更容易理解SpringAOP。

代理模式的优点：将通用性工作交给代理对象处理，被代理对象只需要关注自己的业务代码

比如下面这个例子：

这个你会发现开启事务和关闭事务每个方法都需要使用，造成啦代码重复。
这个时候就可以使用代理模式，把这些代码交给代理对象来完成
代理模式分两种：静态代理和动态代理 下面分别介绍

public class StudentDao {
    public void insert(){
        System.out.println("开启事务");
        System.out.println("insert-------");
        System.out.println("提交事务");
    }
    
    public void delete(){
        System.out.println("开启事务");
        System.out.println("delete-------");
        System.out.println("提交事务");
    }
}
一、SpringAOP----静态代理

静态代理只能为特定的类产生代理对象，不能代理任意类
好处：
1、被代理类只需要关注自己的业务代码的实现，将通用型的管理型逻辑（事务管理、日志管理）和业务逻辑分离。
2、 将通用的代码放在代理类中，提高代码的复用性
3、 通过在代理类中添加业务逻辑实现对原有业务逻辑的增强

1.1、创建一个通用代理方法接口

/**
 * @author xxp
 */
public interface GeneralProxy {
    void insert();
    void delete();
}

1.2、创建StudentDao并实现GeneralProxy接口重写方法

public class StudentDao implements GeneralProxy {
    public void insert() {
        System.out.println("StudentInsert");
    }

    public void delete() {
        System.out.println("StudentDelete");
    }
}

1.3、创建BookDao并实现GeneralProxy接口重写方法

public class BookDao implements GeneralProxy {
    public void insert() {
        System.out.println("BookInsert");
    }

    public void delete() {
        System.out.println("BookDelete");
    }
}

1.4、创建代理类，定义通用的方法，如：开启事务，提交事务

/**
 * 静态代理类
 * @author xxp
 */
public class MyProxy {
    private GeneralProxy generalProxy;
	//这个构造方法是重点，它决定代理哪个类
    public MyProxy(GeneralProxy generalProxy) {
        this.generalProxy = generalProxy;
    }

    public void insert() {
        begin();
        generalProxy.insert();
        commit();
    }

    public void delete() {
        begin();
        generalProxy.delete();
       commit();
    }
    public void begin(){
        System.out.println("开启事务");
    }
    public void commit(){
        System.out.println("提交事务");
    }
}

1.5、测试类

public class MyTest {
    public static void main(String[] args) {
        BookDao bookDao = new BookDao();
        StudentDao studentDao = new StudentDao();
//这里就实现啦代理，参数可以是bookDao也可以是 studentDao
        MyProxy myProxy = new MyProxy(bookDao);
        myProxy.delete();

    }
}
二、SrpingAOP----动态代理

静态代理有个缺点，就是只能代理实现啦特定接口的类。
动态代理则可以代理几乎所有的类。
动态代理实现的方式有两种：
1.JDK动态代理
2.CGLib动态代理

2.1、JDK动态代理

JDK动态代理是通过被代理对象实现的接口（这也是它的缺点）产生其代理对象的
实现步骤
1.创建一个类，实现InvocationHandler接口，重新invoke方法
2.定义一个Object类型的变量，并提供其有参构造方法，方便被代理对象传递进来
3.定义getProxy方法来获取被代理对象的实现的接口，并为它创建代理对象返回出去（这个过程是通过反射实现的）


/**
 * JDK动态代理
 * @author xxp
 */
public class JDKDynamicProxy implements InvocationHandler {
    //定义一个Object类型的变量，并提供其有参构造方法，方便被代理对象传递进来
    private Object object;
    public JDKDynamicProxy(Object object) {
        this.object = object;
    }

    public Object getProxy(){
        //获取被代理对象的类加载器
        ClassLoader loader = object.getClass().getClassLoader();
        //获取被代理对象实现的接口
        Class<?>[] interfaces = object.getClass().getInterfaces();
        //产生代理对象（通过被代理对象的类加载器及实现的接口）
        //1、第一个参数 被代理对象的类加载器
        //2、第二个参数 被代理对象实现的接口
        //3、第三个参数 用于拦截 产生的代理对象 调用的方法
        Object proxyInstance = Proxy.newProxyInstance(loader, interfaces, this);
        return proxyInstance;
    }


    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        begin();
        Object invoke = method.invoke(object，args);
        commit();
        return invoke;
    }

    public void begin(){
        System.out.println("开启事务");
    }
    public void commit(){
        System.out.println("关闭事务");
    }
}

测试类

public class MyTest {
    public static void main(String[] args) {
        BookDao bookDao = new BookDao();
        StudentDao studentDao = new StudentDao();
        //产生代理对象
        JDKDynamicProxy jdkDynamicProxy = new JDKDynamicProxy(bookDao);
        GeneralProxy proxy = (GeneralProxy) jdkDynamicProxy.getProxy();
        //使用代理对象调用方法时候并不会执行方法，而是被拦截啦进入到啦InvocationHandler中的invoke方法
        //调用的方法被作为参数传递给啦method
        proxy.delete();
    }
}
2.2、CGLib动态代理

前面的JDK动态代理有一个缺点：被代理的类必须实现接口
所以这里介绍另一个代理，CGLib动态代理
CGLib动态代理是通过创建被代理类的子类来创建代理对象的，因此没有实现接口的对象也可以创建代理对象
实现步骤：
1.创建一个类，实现MethodInterceptor接口，重写intercept方法
2.定义一个Object类型的变量，并提供其有参构造方法，方便被代理对象传递进来
3.定义getProxy方法来获取被代理对象，通过创建被代理对象的子类来实现

导入依赖

        <!-- https://mvnrepository.com/artifact/cglib/cglib -->
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

代理类

/**
 * CGLib‘动态代理
 * @author xxp
 */
public class CGLibDynamicProxy  implements MethodInterceptor {
    private Object object;

    public CGLibDynamicProxy(Object object) {
        this.object = object;
    }

    public Object getProxy(){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(object.getClass());
        enhancer.setCallback(this);
        Object proxy = enhancer.create();
        return proxy;
    }
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        begin();
        Object returnValue = method.invoke(object, objects);
        commit();
        return returnValue;
    }

    public void begin(){
        System.out.println("开启事务");
    }
    public void commit(){
        System.out.println("关闭事务");
    }
}

测试类


/**
 * @author xxp
 */
public class MyTest {
    public static void main(String[] args) {
        BookDao bookDao = new BookDao();
        StudentDao studentDao = new StudentDao();
     
        CGLibDynamicProxy cgLibDynamicProxy = new CGLibDynamicProxy(bookDao);
        BookDao bookDaoProxy = (BookDao) cgLibDynamicProxy.getProxy();
        bookDaoProxy.delete();
    }
}
三、SpringAOP
3.1、AOP

AOP面向切面编程，是一种利用“横切的技术”（底层实现就是动态代理），对原有的逻辑进行拦截，并且可以在这个横切面上进行添加特定的业务逻辑，对原有代码进行增强
简单来说就是基于动态代理实现在不改变原有业务的情况下对业务逻辑进行增强。
专业术语：
切点：要增强的方法
切面：增强类
通知：织入切点处（这个通知分好多，后续详细介绍）

下面的例子是对studentDao中的insert和delete方法进行增强
导入依赖

      </dependency>
    <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver --> <dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

定义切面

/**
 * 事务切面
 * @author xxp
 */
public class TxManager {
    public void begin(){
        System.out.println("开启事务！");
    }
    public void commit(){
        System.out.println("关闭事务！");
    }
}

创建studentDao

/**
 * @author xxp
 */
public class StudentDao {
    public void insert(){
        System.out.println("student添加");
    }
    public void delete(){
        System.out.println("student删除");
    }
}

配置文件

	<bean id="studentDao" class="com.xxp.dao.StudentDao"></bean>
	<!--切面类必须交给spring容器管理-->
	<bean id="txManager" class="com.xxp.util.TxManager"></bean>

	<aop:config>
	<!--声明切点-->
		<aop:pointcut id="studentDaoInsert" expression="execution(* com.xxp.dao.StudentDao.delete())"/>
	<!--声明切面-->
		<aop:aspect ref="txManager">
			<!--声明通知-->
			<aop:before method="begin" pointcut-ref="studentDaoInsert"/>
			<aop:after method="commit" pointcut-ref="studentDaoInsert"/>
		</aop:aspect>
	</aop:config>

</beans>

测试类

/**
 * @author xxp
 */
public class AspetTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
       StudentDao studentDao = (StudentDao) context.getBean("studentDao");

        studentDao.delete();
    }
}
3.2、通知的详解

AOP中通知分为：
前置通知：在指定切点的前面执行
后置通知：在指定切点的后面执行
环绕通知：在指定切点的前后执行


	<bean id="studentDao" class="com.xxp.dao.StudentDao"></bean>

	<bean id="txManager" class="com.xxp.util.TxManager"></bean>

	<aop:config>
	<!--声明切点-->
		<aop:pointcut id="studentDaoInsert" expression="execution(* com.xxp.dao.StudentDao.delete())"/>
	<!--声明切面-->
		<aop:aspect ref="txManager">
			<!--声明通知-->
			<!--前置通知-->
			<aop:before method="begin" pointcut-ref="studentDaoInsert"/>
			<!--后置通知-->
			<aop:after method="commit" pointcut-ref="studentDaoInsert"/>
			<!--环绕通知-->
			<aop:around method="method5" pointcut-ref="studentDaoInsert"/>
		</aop:aspect>
	</aop:config>
四、SrpingAop注解实现

@Aspect声明该类为切面类
@Pointcut声明切点
@Before前置通知
@After后置通知
@Around环绕通知

配置文件

<!--开启注解配置-->
	<context:annotation-config/>
<!--	注解扫描的范围-->
	<context:component-scan base-package="com.xxp"/>
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

切面类


/**
 * 事务切面
 * @author xxp
 */
@Component
@Aspect
public class TxManager {
    @Pointcut("execution(* com.xxp.dao.StudentDao.*(..))")
    public void tx() {
    }

    @Before("tx()")
    public void begin(){
        System.out.println("开启事务！");
    }
    @After("tx()")
    public void commit(){
        System.out.println("关闭事务！");
    }
    @Around("tx()")
    public Object method5(ProceedingJoinPoint point) throws Throwable {
        System.out.println("------环绕通知--前------");
        Object proceed = point.proceed();
        System.out.println("-------环绕通知---后------");
        return proceed;
    }
}
秋水调威士忌
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot快速搭建Spring框架教程
08-29
主要为大家详细介绍了Spring Boot快速搭建Spring框架教程，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Spring快速入门超详细讲解
南 阳 的博客
07-02 2455
在Spring框架规范中，所有由spring管理的对象都称之为Bean对象。Spring提供了以下多个注解，这些注解可以直接标注在java类上，将它们定义成Spring Bean。注解说明@Component该注解用于描述Spring中的Bean，它是一个泛化的概念，仅仅标识容器中的一 个组件（Bean），并且可以作用在任何层次，例如Service层、Dao层等，使用时只需将该注解标注在相应的类上即可。
Spring入门第一讲——Spring框架的快速入门
m0_67393157的博客
08-25 656
IoC即Inversion of Control，反应过来就是控制反转。啥是控制反转啊？控制反转指的就是将对象的创建权反转给（交给）了Spring，其作用是实现了程序的解耦合。也可这样解释：获取对象的方式变了，对象创建的控制权不是"使用者"，而是"框架"或者"容器"。用更通俗的话来说，IoC就是指对象的创建，并不是在代码中用new操作new出来的，而是通过Spring进行配置创建的。
Spring框架系列教程
m0_75198698的博客
05-08 163
18. Spring Integration：介绍Spring框架的集成解决方案，可以集成各种不同的应用程序和服务，包括数据库、消息队列、Web服务等。在这一部分，我们将介绍Spring框架的Web开发支持，包括Spring MVC、Spring WebFlux和Spring Boot。以上是一个Spring框架系列教程的大纲，您可以根据您的学习需求，逐一学习这些内容。15. Spring AOP：介绍Spring框架中的面向切面编程（AOP）功能，包括切面、连接点、切入点、通知、顾问等。
Spring使用教程
weixin_74265534的博客
09-12 709
一.容器相关BeanFactory是IOC容器的顶层接口，初始化BeanFactory对象时，加载的bean延迟加载。ApplicationContext接口是Spring容器的核心接口，初始化bean立即加载。ApplicationContext接口提供基础的bean操作相关方法，通过其他接口扩展其功能ApplicationContext接口常用初始化类：ClassPathXmlApplicationContext,FileSystemXmlApplication二.bean相关。
Spring 最全入门教程详解
lucky_fd的博客
07-04 2904
Spring 基础框架，可以视为Spring 基础设施，基本上任何其他 Spring 项目都是以 SpringFramework 为基础的。Spring 5 的模块结构图: lOC: Inversion of Control，翻译过来是反转控制。把对象创建和对象之间的调用过程，交给 Spring 进行管理Spring 的IOC 容器就是IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建 bean 之前，首先需要创建IOC容器。Spring 提供了IOC容器的两种实现方式：
spring 框架教程
03-15
java 开发框架 代码程序实例内部课程资料
spring框架教程 PPT
11-02
spring框架教程 PPT ppt
spring框架简单教程
01-28
spring框架简单教程,通俗易懂.控制反转,依赖注入 IOC
spring框架2016
08-26
最新spring框架2016视频教程，包含源码和笔记。小白入手实用教程。
springmvc入门参数绑定ssm整合
11-10
springmvc入门参数绑定，ssm整合。新手来学springmvc时候特别好用。我老师发的。
Spring框架学习教程(一)
12-26
完整系列的Spring教程，这只其中的一部分，接下来的时间会一次上传。
spring权限框架教程
06-29
spring security权限框架简要介绍， 可结合文档和官网编写个小Demo
Spring框架入门教程
12-09
Spring框架入门教程
spring框架约束步骤及教程
03-21
Spring框架约束资源与步骤欢迎大家使用，Spring框架约束文件 sspring-core-4.1.6.RELEASE-sources.jar spring-core.jar 这个jar文件包含Spring框架基本的核心工具类，Spring其他组件都要使用到这个包里的类，是其他...
Spring框架学习
xiaocheng194的博客
12-22 242
Spring介绍 Spring框架是 针对bean的生命周期进行管理的轻量级容器 知识补充: 1,J2SE java基础 J2EE java企业级开发 J2ME 移动端开发 2,bean spring容器管理的对象,称之为bean 3,生命周期 : 对象创建 对象的初始化 对象执行业务逻辑 对象的销毁 4,轻量级容器: Spring在内存中申请了一块内存空间,用来存储其它对象 知识铺垫: 面向接口编程: 说明: 将子类中的方法 进行高级的抽取,抽取到接口中 这...
Spring框架实战入门(超全面，超实用)
宗小张的博客
08-20 1407
Spring框架实战入门第一部分 Spring概述1.1.Spring框架是什么1.2.Spring的优点1.3.Spring体系结构第二部分 IOC控制反转2.1.开发工具准备2.2.Spring的第一个程序2.2.1.创建maven项目2.2.2.引入maven依赖pom.xml2.2.3.定义接口和实现类2.2.4.创建Spring配置文件2.2.5.定义测试类2.2.6.使用spring创建非自定义类对象2.2.7.容器接口和实现类2.3.基于XML的DI2.3.1.注入分类1) set注入1) 构
Spring框架入门
weixin_44279647的博客
08-23 2596
1.Spring框架是什么 Spring是一个轻量级的控制反转（IOC）和面向切面（AOP）的容器框架 1.什么时IOC IOC(inversion of control 控制反转)，控制反转（IOC）与依赖注入（DI）是同一个概念 具体的讲：当某个对象需要调用另一个对象，在传统的程序设计过程中，通常由调用者来创建被调用者的实例，但是在spring中使用了工厂设计模式，为我们创建了所需要的对象，直接调用spring提供的对象就可以了。 引入IOC的目的： 脱开，降低类之间的耦合； 倡导面向接
史上最全面最易懂的，Spring框架学习教程
assdfgdfgjhtdo的博客
09-14 836
Spring通过PlatformTransactionManager平台事务管理器接口对事务的管理进行高度抽象，但是该接口下具体的实现是由各个平台自己实现，Spring并不直接管理事务，而是提供了多种事务管理器，也就是对各个平台的事务管理进行封装，最终将事务管理的职责委托给JDBC、Hibernate、JPA、JMS、MongoDB等持久化平台框架的事务来实现。 本套Spring课程，是动力节点王鹤老师讲解的，主要讲了Spring4在SSM框架中的使用及运用方式。 内容涵盖了实际工作中可能用到的几乎所有
spring框架下载教程
最新发布
10-17
您可以按照以下步骤下载Spring框架： 1. 访问Spring官网 https://spring.io/，点击“Get Started”按钮。 2. 在“Choose what to start with”下拉菜单中选择“Spring Framework”。 3. 在“Choose a version”下拉...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值