Spring框架的学习心得

最新推荐文章于 2022-05-22 14:54:51 发布

原创最新推荐文章于 2022-05-22 14:54:51 发布 · 1.4k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#sping #Ioc #AOP

Spring框架专栏收录该内容

1 篇文章

订阅专栏

本文深入解析Spring框架如何简化项目开发，通过IoC容器实现对象自动实例化与依赖注入，降低类间耦合度，增强代码灵活性。同时，介绍AOP机制在不修改源代码情况下，实现日志打印、事务处理等功能。

Spring框架能解决的问题

Spring框架是简单、高效的集成开发环境，能够帮助我们在复杂繁琐的工作中简单高效的完成项目开发
Spring框架中的IoC容器能够实现对JAVABean的自动实例化以及JAVA类中属性的依赖注入
Spring框架中的IoC容器能够解耦，降低类与类之间的耦合度；提升代码的灵活性、可扩展性和可维护性。
Spring框架中还提供了方便我们实现额外功能的机制即AOP，能够在不改变JAVA本身代码的前提下，去帮助我们实现额外的功能，例如：日志打印、事务处理、性能检测等。
Spring框架适用于任何JAVA，它就相当于一个海纳百川的容器，能够容纳所有的框架，在不改变其他框架任何代码的情况下，实现对框架的整合。

IOC（Inversion of control）即反转控制

概念：在实际开发中，我们失去了原本对对象的控制权，把创建对象的控制权转移到了Spring容器，由Spring容器来帮助我们创建对象，并把对象的引用传递给依赖这个对象的变量，即依赖注入。

IoC解决的问题：创建对象、依赖注入对象引用（其他数据类型也可以实现依赖注入），下面实际举例说明传统的new实例化对象与Spring框架创建对象以及依赖注入的不同：

实际开发中我们一般的创建对象的方式是使用new关键字：

Public class UserServiceImple implements UserService{
	//实例化对象
	private UserDAO userDao = new UserDAOImpl();
}

当我们使用Spirng框架实现实例化对象以及依赖注入的步骤如下：

步骤1：删除new关键字创建对象，声明属性和创建属性的setter方法

Public class UserServiceImple implements UserService{
	//声明属性
	private UserDAO userDAO;
	
	public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
}

步骤:2：配置xml文件

<bean id="userDAO"  class="com.wb.springdemo.dao.impl.UserDAOImpl“/>

IoC的配置方式：

bean实例化的四种方式

默认构造器实例化方式（Spring容器默认调用class全类名中的空参构造函数实例化对象）

只需要配置xml文件中的bean示例：**<bean id="userDAO" class="com.wb.springdemo.dao.impl.UserDAOImpl“/>**

静态工厂实例化方式（Spirng容器调用class全类名中的静态方法实例化对象）

配置xml文件示例：<bean id=“connection” factory-method=“getConnection” scope=“prototype” class="com.wb.springdemo.utils.JDBCUtils“/>

工厂bean实例化方式

配置xml文件示例：

<bean id ="carFactory" class="com.wb.springdemo.factory.CarFactory" />
	<bean id ="car" factory-method="createCar" factory-bean="carFactory">< /bean>

Spring中提供的FactoryBean接口实现工厂bean

步骤1：创建一个学生工厂类StudentFactory实现FactoryBean接口，实现接口中的方法，示例如下:

public class StudentFactory implements FactoryBean< Student > {
    public Student  getObject() throws Exception {
        return new Student();
    }
    public Class<?> getObjectType() {
        return Student.class;
    }
}

步骤2：配置xml文件

<bean id ="student" class="com.wb.springdemo.factory.StudentFactory" />

依赖注入的两种方法：

setter注入法

步骤1：声明属性和创建属性的setter方法

Public class UserServiceImple implements UserService{
	//声明属性
	private UserDAO userDAO;
	
	public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
}

步骤:2：配置xml文件

<bean id="userDAO"  class="com.wb.springdemo.dao.impl.UserDAOImpl“/>

构造器注入

步骤1：声明属性和创建对应属性的构造方法

Public class UserServiceImple implements UserService{
	//声明属性
	private UserDAO userDAO;
	//声明基本数据类型
	private int age;
	//声明数组类型
	private List<String> data;
	//对应属性的构造方法
	 public UserServiceImpl(UserDAO userDAO, int age, List<String> data) {
        this.userDAO = userDAO;
        this.age = age;
        this.data = data;
    }

步骤2：配置xml文件

<bean id="userService" class="com.wb.springdemo.service.impl.UserServiceImpl">
	<!-- 构造器注入   -->
     <constructor-arg name="userDAO" ref="userDAO"></constructor-arg>
     <constructor-arg name="age" value="18"/>
     <constructor-arg name="data">
            <list>
                <value>controller</value>
                <value>dao</value>
                <value>service</value>
            </list>
     </constructor-arg>
</bean>

Spring中bean的作用域和生命周期

bean的作用域：默认是单例的

bean标签的scope属性用于表示作用域范围
scope属性的取值：（默认取值单例scope="singleton”）
prototype 多例对象–>每创建一个对象创建一个新的实例
singleton 单例对象–>一个bean的定义，只有一个实例。不是一个类只有一个实例。
request 一个请求一个实例
session 一个会话一个实例
websocket 一次websocket链接一个实例

生命周期

单例对象：
初始化：Spring容器创建时对象初始化
生存期：只要容器还在，对象就存在
销毁期：容器销毁，对象就销毁
总结：单例对象的生命周期和Spring容器的生命周期想相同
多例对象：
初始化：当我们使用对象时Spring容器才为我们创建对象
生存期：对象只要是在使用过程中就一直存在
销毁期：当对象长时间不使用时，且没有别的对象引用时，由java的垃圾回收器回收。

生命周期代码实现的两种方式

方式1：在类中自定义两个方法来实现，表示开始和结束
步骤1：自定义开始和结束的方法

Public class UserServiceImple implements UserService{
 //自定义开始方法
 public void beanStart(){
        System.out.println("...bean开始了...");
    }
 //自定义结束方法
 public void beanEnd(){
        System.out.println("...bean结束了...");
    }
}

步骤2：配置xml中对应bean的init-method和destroy-method

 <bean id="userService" init-method="beanStart" destroy-method="beanEnd"  class="com.wb.spring.service.impl.UserServiceImpl">
 </bean>

步骤3：创建main方法验证bean的生命周期

 public static void main(String[] args) {
 		//创建Spring容器对象ac
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("aplicationContext.xml");
        userService userService= ac.getBean("userService", UserService.class);
        //销毁ac容器对象
        ac.close();
    }

方式2：只需要类实现InitializingBean接口和DisposableBean接口即可。

public class Cycle implements InitializingBean, DisposableBean {
	//bean开始的方法
    public void afterPropertiesSet() throws Exception {
        System.out.println("开始。。。");
    }
	//bean结束的方法
    public void destroy() throws Exception {
        System.out.println("结束。。。");
    }
}

IoC的优势

Sping中IoC容器可以帮助我们创建对象以及依赖注入
IoC容器能够解耦，降低类与类的耦合度
使用IoC容器能够提升代码的灵活性、可扩展性和可维护性。

AOP的介绍

AOP的概念：

全称是Aspect Oriented Programming，即面向切面编程。通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP的应用场景

打印日志
性能监测
事务管理
安全验证

AOP的配置方式

方式1：纯XML文件的配置

步骤1：在pom.xml文件中导入依赖包

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.4</version>
    </dependency>

步骤2：编写Service类

public class UserServiceImpl implements UserService {
    @Override
    public void addUser(User user) {
    System.out.println("添加User成功!");
}
    public  void addTest(){
        System.out.println("测试add方法");
    }
}

步骤3：编写通知，实现MethodBeforeAdvice接口

public class AdviceDemo implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("方法:"+method+"参数:"+ Arrays.toString(args)+"目标对象："+target);
    }
}

步骤4：配置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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 配置目标对象   -->
    <bean id="userService" class="com.wb.springaop.service.impl.UserServiceImpl"/>
<!-- 配置通知-->
    <bean id="adviceDemo" class="com.wb.springaop.compent.AdviceDemo"/>
<!-- 配置切入点   -->
    <bean id="pointCut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">
        <property name="pattern" value="com.wb.springaop.service.impl.UserServiceImpl.add.*"></property>
    </bean>
<!--  配置切面  -->
    <bean id="aspect" class="org.springframework.aop.support.DefaultPointcutAdvisor">
<!--  组装通知  -->  <property name="advice" ref="adviceDemo"/>
<!--  组装切入点  -->  <property name="pointcut" ref="pointCut"/>
    </bean>
<!-- 包装Service类 -->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
</beans>

方式2：XML和注解

步骤1：同方式1，在pom.xml文件中导入依赖包
步骤2：编写service类并注解

@Service("userService")
public class UserServiceImpl implements UserService {
   @Override
    public void addUser(User user) {
    System.out.println("添加User成功!");
}
    public  void addTest(){
        System.out.println("测试add方法");
    }
}

步骤3：编写切面类

@Component
@Aspect
public class TxAdvice {
    //编写切入点
    @Pointcut("execution(* com.wb.springaop.service.impl.*.* (..))")
    public void servicePointcut(){}
    //编写通知
    @Around("servicePointcut()")
    public Object invokeMethod(ProceedingJoinPoint pjp) {
        //参数
        Object result = null;
        Object[] args = pjp.getArgs();
        try {
            System.out.println("...开启事务...");
            result = pjp.proceed(args);
            System.out.println("...提交事务...");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("...回滚事务...");
        }
        return result;
    }
}

步骤4：编写JAVA配置文件类

@Configuration
@ComponentScan("com.wb.springaop")
@EnableAspectJAutoProxy
public class AopConfig {
}

步骤5：编写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"
       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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--配置扫描的包-->
  <context:component-scan base-package="com.wb.springaop"/>
<!--启动aspectj自动生成代理类-->
  <aop:aspectj-autoproxy/>
</beans>