Spring

多又多

已于 2022-02-15 10:07:17 修改

阅读量121

点赞数

分类专栏： JAVA知识总结文章标签： spring

于 2022-02-14 14:49:59 首次发布

原文链接：https://blog.csdn.net/u012932876/article/details/118487949?spm=1001.2014.3001.5502

版权

JAVA知识总结专栏收录该内容

13 篇文章 2 订阅

订阅专栏

1.初识Spring框架

时代变迁

原始时代我们用一个jsp搞定一切，但如此开发大型项目时我们遇到了问题，前端美化的代码和后端的代码交织，代码中又有html、js、css样式，又有业务逻辑和数据库访问代码，杂乱不清晰，美工和开发打架。

于是mvc分层架构封建时代出现，把我们写代码的地方硬性分成3个地方，Model层封装数据，View视图层页面展现，Controller控制层访问转发。代码之间的耦合度降低。概念有了，需要实际干活的。于是随着mvc分层概念的深入人心，业界涌现出很多实现框架，最著名的莫过于struts1和struts2。随着前端框架的成熟，后端框架也应运而生如：dbutils、jdbcTemplate、hibernate、ibatis、mybatis。

一个前端WEB层框架有了，一个后端数据库层访问框架有了，那中间呢？谁来胜任？spring破石而出。

Spring的野心

了解了历史，有个问题值得我们去深思？spring到底想干什么？

它想把全球最好的技术组合到一起，为企业提供高质量的企业级的应用程序框架，减轻开发者开发的难度，减少重复的代码。

目标很宏大，那如何下手呢？如果是你，你会怎么实现？第一步要干什么呢？

我们拿经典的框架来举例子。

struts2作为WEB框架深受企业爱戴，它会自己管理action，来创建其实例，这样在程序中就可以访问action的资源。hibernate作为持久层优秀的框架，它也自己管理持久对象。可以看到，各个诸侯都自己管理对象，而要想让它们对象复用，那真是繁琐。前面就有失败者WebService，为了管理不同的开发语言的对象而层层包装转换，辛苦制定的规则，还借着J2EE规范之名，也推广不开。

如何破局呢？想发号施令，想让人听从，最好的解决办法就是扼住他们的咽喉。在java的世界里最重要的无疑就是对象的生命周期管理。于是spring以此为切入点，实现自己的统治。官宣所有对象由我来管理，struts2你不再管理对象，由我来管理，你要用从我这拿。hibernate你也不再管理对象，由我来管理，你要用从我这拿。你说管就能管的吗？这两个征战数年战功赫赫的大将军会听一个初出茅庐乳臭未干野小子的话？他们当然不会听，spring的话可以不听，但他们都要听开发者的。开发一个完整的系统有四个核心，WEB层支持、业务逻辑层、持久层支持、事务支持。而这就是它们的软肋，这就是它们的命门所在，它们只能完成一部分工作，不是一个整体解决方案。而spring并没有抹杀它们，而是依然给它们高官厚禄，承认它们的市场地位，还赠与一个事务管理。一边打压一边拉拢，它们两位看看大势已去，只能俯首称臣。于是兵不血刃，一场变革悄然兴起，一个经典的三层框架诞生SSH （Strut2+Spring+Hibernate）。

故事很传奇，听的人很开心。可spring真就这么简单吗？如果这样想，你就大错特错了。例如：spring怎么来实现对象的管辖？怎么让不同技术之间能简单的互相配合？这才是spring的决胜之处。

为实现这些spring可是绞尽脑汁、煞费苦心呢。它创新的形成了一套新的理论体系，可谓前无古人后无来者。其中最核心的是：IoC控制反转、DI依赖注入、Bean工厂、SpringAOP面向切面编程、事务控制。

并且spring并没有停止不前，这只是统治地球的第一步，随着spring占领市场后，开始对有功之臣进行清洗，struts2不再优秀，致命bug层出不穷，刚好落井下石，spring推出了springmvc，最终终结了struts2。hibernate想用jdbcTemplate和jdo替代，却被mybatis超越，目前还未统一。世界又达到新的平衡，经典的新三大框架诞生，SSM（SpringMVC+Spring+MyBatis）。Spring并没有放弃，而是另辟蹊径，推出新的产品SpringBoot+SpringCloud 微服务，目前新的趋势已经尘埃落定，一统江湖！

官网

http://spring.io
在这里插入图片描述

框架组成

在这里插入图片描述
Spring是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。Spring框架的不光是技术牛，而是它的核心思想更牛，它不重复发明轮子，而是"拿来主义"，把业界做的最好的技术黏合起来形成一个强大的企业级的应用框架。

Spring 框架是一个分层架构，由7个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如下图所示：
在这里插入图片描述
组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

Spring 框架的功能可以用在任何J2EE服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定J2EE服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同J2EE环境（Web或EJB）、独立应用程序、测试环境之间重用。

Spring以一种非侵入式的方式来管理你的代码，Spring提倡"最少侵入"，这也就意味着你可以适当的时候安装或卸载Spring ，但这点越来越模糊。

核心概念

在这里插入图片描述

三大核心组件的关系

Bean、Context、Core三大核心组件的关系：

Bean 包装的是 Object，而 Object 必然有数据，如何给这些数据提供生存环境就是 Context要解决的问题，对 Context 来说它就是要发现每个 Bean 之间的关系，为它们建立这种关系并且要维护好这种关系。所以 Context 就是一个Bean关系的集合，这个关系集合又叫 Ioc 容器，一旦建立起这个 Ioc 容器后 Spring 就可以为你工作了。那 Core 组件又有什么用武之地呢？其实Core 就是发现、建立和维护每个 Bean 之间的关系所需要的一些类的工具，从这个角度看来，Core 这个组件叫 Util 更能让你理解。

把Bean 比作一场演出中的演员的话，那 Context 就是这场演出的舞台背景，而 Core应该就是演出的道具了。只有他们在一起才能具备能演出一场好戏的最基本的条件。当然有最基本的条件还不能使这场演出脱颖而出，还要他表演的节目足够的精彩，这些节目就是 Spring 能提供的特色功能了。

主要jar组成

在这里插入图片描述

2.Spring框架两大核心：IoC和DI

概念

IoC（Inversion of Control）简单来说就是将对象Object的创建的权力及对象的生命周期的管理过程交由Spring框架来处理，从此在开发过程中不在需要关注对象的创建和生命周期的管理，而是在需要的时候由Spring框架提供，这个由Spring框架管理对象创建和生命周期的机制称之为控制反转。
在创建对象的过程中Spring可以依据对象的关系，自动把其它对象注入（无需创建对象，直接拿着使用）进来，这个过程称之为DI（Dependency Injection）依赖注入。
总结下Spring核心就干了两件事：
（1）创建对象
（2）设置对象的关联关系

IoC

IOC（Inversion of Control），控制反转。

就是指将对象的创建，对象的存储(map)，对象的管理(依赖查找,依赖注入)交给了spring容器。
在这里插入图片描述

DI

DI（Dependency Injection）依赖注入。

相对于IoC而言，依赖注入(DI)更加准确地描述了IoC的设计理念。所谓依赖注入，即组件之间的依赖关系由容器在应用系统运行期来决定，也就是由容器动态地将某种依赖关系的目标对象实例注入到应用系统中的各个关联的组件之中。
在这里插入图片描述

3.IoC的XML方式

创建springboot工程

创建Hello.java

package cn.tedu.spring;

public class Hello {
    public void show(){
        System.out.println("show()被调用成功!");
    }
}

创建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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        spring认为万物都是bean,只要你的类,交给spring框架,spring就能IOC
        IOC是控制反转:是指Spring框架会帮你创建对象,你来获取对象
        id属性是每个bean标签的唯一标识,class属性是用来指定类的全路径
        IOC底层Map的数据结构{类,类的对象}
     -->
    <bean id="hello" class="cn.tedu.spring.Hello"></bean>

</beans>

创建测试类,直接获取对象

package cn.tedu.ioc;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    //junit单元测试方法:测试一段代码的结果@Test
    @Test
    public void get(){
        //1,读取配置文件--参数是配置文件的名字
        ClassPathXmlApplicationContext spring =
                new ClassPathXmlApplicationContext(
                            "spring.xml");
        //2,获取对象--参数是配置文件里,bean标签的id的属性值
        Object o = spring.getBean("hello");
        //cn.tedu.spring.Hello@4550bb58
        System.out.println(o);
    }
}

练习：
–1,创建配置文件spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--suppress SpringFacetInspection -->
<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">
    <!--
        spring认为万物都是bean,只要你的类,交给spring框架,spring就能IOC
        IOC是控制反转:是指Spring框架会帮你创建对象,你来获取对象
        id属性是每个bean标签的唯一标识,class属性是用来指定类的全路径
        IOC底层Map的数据结构
        {"hello",Class.forName("cn.tedu.spring.Hello").newInstance()}
        scope="prototype" 可以设置bean对象是单例的还是多例的,默认是singleton是单例的
     -->
    <bean id="hello" class="cn.tedu.spring.Hello"></bean>

    <!--IOC:底层就是Map结构,key是id的值,value是根据class的值反射创建的对象
     {"student",Class.forName("cn.tedu.spring.Student").newInstance() }
     -->
    <bean id="student" class="cn.tedu.spring.Student"></bean>

</beans>

–2,创建测试类

package cn.tedu.ioc;
import cn.tedu.spring.Hello;
import cn.tedu.spring.Student;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    //junit单元测试方法:测试一段代码的结果@Test
    @Test
    public void get(){
        //1,读取配置文件--参数是配置文件的名字
        ClassPathXmlApplicationContext spring =
                new ClassPathXmlApplicationContext(
                            "spring.xml");
        //2,获取对象--参数是配置文件里,bean标签的id的属性值
        Object o = spring.getBean("hello");
        //cn.tedu.spring.Hello@4550bb58
        System.out.println(o);
        Hello h = (Hello) o;//向下转型--使用子类自己的资源
        h.show();

        Object o2 = spring.getBean("hello");
        //cn.tedu.spring.Hello@4550bb58
        System.out.println(o2);//地址值

        Object o3 = spring.getBean("student");
        System.out.println(o3);//cn.tedu.spring.Student@38425407
        Student s = (Student)o3;//向下转型
        s.add();
    }
}

小结

这就是spring框架的IoC，控制反转。之前我们自己new出新类。new User();变成由一个初始化的xml配置文件来创建，也就是由spring容器来创建。遍历xml配置文件，读取到，获取到class属性的类的全路径，利用反射创建这个类。

在java范畴中万物皆Object,在Spring中万物皆Bean。Bean是Spring的核心、基础、根源。

4. IoC的注解方式

常用的IOC注解有四个: 功能都一样,都是交给spring框架创建对象
@Component @Service @Controller @Repository

创建springboot工程

–1,定义类使用注解@Component

package cn.tedu.spring;
import org.springframework.stereotype.Component;
@Component//IOC,让spring去new
public class Order {
    public void save(){
        System.out.println(1000);
    }
}

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>cn.tedu</groupId>
	<artifactId>spring</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<!-- 集中定义依赖版本号 -->
	<properties>
		<junit.version>4.10</junit.version>
		<spring.version>4.1.3.RELEASE</spring.version>
	</properties>

	<dependencies>
		<!-- 单元测试 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit.version}</version>
			<scope>test</scope>
		</dependency>

		<!-- Spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>

	</dependencies>
</project>

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 https://www.springframework.org/schema/context/spring-context.xsd">

    <!--用包扫描的机制,代替以前bean标签的配置
    IOC的本质是底层创建一个Map集合{类名的首字母变小写,类的对象}
    区别:以前一个类必须配置对应的bean标签,
        现在是只要在扫描的范围内而且使用了IOC注解的spring都会new
    base-package:指定包的路径
    包扫描的范围要适当的控制,范围越小扫描的速度越快
    -->
    <context:component-scan base-package="cn.tedu.spring"></context:component-scan>
</beans>

##–3,测试

package cn.tedu.ioc;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    @Test
    public void get(){
        //1,读取配置文件
        ClassPathXmlApplicationContext spring =
                new ClassPathXmlApplicationContext(
                        "spring.xml");
        //2,直接getBean
        Object o = spring.getBean("order");
        System.out.println(o);//cn.tedu.spring.Order@26275bef
        Object o2 = spring.getBean("order");
        System.out.println(o2);
    }
}

–4,总结
1, 创建类, 并且一定要使用IOC注解(@Component @Controller @Service @Repository)
2, 配置包扫描, 需要指定包的路径, 包的扫描范围越小越好, 合理的定范围就可以
3, IOC本质就是, 把你创建的类,Spring框架创建对象,存入Map集合里.
key是类名(首字母小写) value是类的对象(框架利用反射来创建的对象)
Map -> { “hello” , Class.forName(“Hello类的全路径”).newInstance()

5. DI依赖注入

创建Maven工程

在这里插入图片描述

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>cn.tedu</groupId>
	<artifactId>spring</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<!-- 集中定义依赖版本号 -->
	<properties>
		<junit.version>4.10</junit.version>
		<spring.version>4.1.3.RELEASE</spring.version>
	</properties>

	<dependencies>
		<!-- 单元测试 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit.version}</version>
			<scope>test</scope>
		</dependency>

		<!-- Spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>

	</dependencies>
</project>

Dept.java

package spring.pojo;
import org.springframework.stereotype.Component;
@Component
public class Dept {
	 String name = "java开发部";

    @Override
    public String toString() {
        return "Dept{" +
                "name='" + name + '\'' +
                '}';
    }
}

User.java

package spring.pojo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class User {
	String name = "jack";
    @Autowired  //相当于框架完成了:new User().setDept(new Dept());
    Dept dept;

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", dept=" + dept +
                '}';
    }
}

applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/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-4.0.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">


	<!-- 扫描包 -->
	<context:component-scan base-package="cn.tedu.spring" />
</beans>

TestDI.java

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import spring.pojo.Dept;
import spring.pojo.User;

public class TestDI {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		Dept d = (Dept)ac.getBean("dept");
		User u = (User)ac.getBean("user");
		
		System.out.println(d);
		System.out.println(u);
		
		System.out.println(u.dept.name);
	}
}

6.小结

面试：IoC和DI

在平时的java应用开发中，我们要实现某一个功能或者说是完成某个业务逻辑时可能需要多个对象来协作完成，在没有使用Spring的时候，每个对象在需要使用他的合作对象时，自己均要使用像new object() 这样的语法来将合作对象创建出来，这个合作对象是由自己主动创建出来的，创建合作对象的主动权在自己手上，自己需要哪个合作对象，就主动去创建，创建合作对象的主动权和创建时机是由自己把控的，而这样就会使得对象间的耦合度高了，A对象需要使用合作对象B来共同完成一件事，A要使用B，那么A就对B产生了依赖，也就是A和B之间存在一种耦合关系，并且是紧密耦合在一起，而使用了Spring之后就不一样了，创建合作对象B的工作是由Spring来做的，Spring创建好B对象，然后存储到一个容器里面，当A对象需要使用B对象时，Spring就从存放对象的那个容器里面取出A要使用的那个B对象，然后交给A对象使用，至于Spring是如何创建那个对象，以及什么时候创建好对象的，A对象不需要关心这些细节问题(你是什么时候生的，怎么生出来的我可不关心，能帮我干活就行)，A得到Spring给我们的对象之后，两个人一起协作完成要完成的工作即可。

所以控制反转IoC(Inversion of Control)是说创建对象的控制权进行转移，以前创建对象的主动权和创建时机是由自己把控的，而现在这种权力转移到第三方，比如转移交给了IoC容器，它就是一个专门用来创建对象的工厂，你要什么对象，它就给你什么对象，有了 IoC容器，依赖关系就变了，原先的依赖关系就没了，它们都依赖IoC容器了，通过IoC容器来建立它们之间的关系。

DI(依赖注入)其实就是IOC的另外一种说法，DI是由Martin Fowler 在2004年初的一篇论文中首次提出的。他总结：控制的什么被反转了？就是：获得依赖对象的方式反转了。

IoC是设计思想，IoC有三个核心：BeanFactory、反射、DI。BeanFactory利用反射实现对象的创建，DI实现对象关系管理。

自动装配

利用注解方式，我们只需要写@Autowired注解，底层就会去容器中找对应的对象，如果有获取到，反射调用其对应的set方法，设置。而这个调用过程都是自动，我们没有手工去写set方法。所以这个过程也称为自动装配。

7.AOP面向切面编程

概念

Spring核心特征中除了IoC控制反转、DI依赖注入，还有一个核心就是强大的面向切面编程AOP（Aspect Oriented Programming）的实现。

Spring AOP有三要素：
（1）Aspect定义切面；
（2）通过通知（Advice）来指定具体做什么事情。如方法执行前做什么，方法执行后做什么，抛出异常做什么，从而实现对象行为（方法）的增强；
（3）具体通过切点（PointCut）配置切点表达式（expression）来指定在哪些类的哪些方法上织入（ware）横切逻辑；被切的地方叫连接点（JoinPoint）；
在这里插入图片描述

通知的执行顺序

Spring框架实现了AOP面向切面，其引入了第三方AspectJ框架来具体实现。AspectJ提供了五种切入方式，术语称为通知advice。

具体五种为：

（1）前置通知before
（2）后置通知after
（3）环绕通知around
（4）返回后通知afterReturning
（5）异常通知afterThrowing。

异常通知特殊，这里暂不讨论。
可以看到，分别在业务方法（Business Method）的执行前后进行拦截，执行指定的代码。
在这里插入图片描述

多切面执行顺序

下面是两个切面各通知的执行顺序：
在这里插入图片描述

使用步骤

1, 加入jar包

<dependencies>
     <!--添加aop依赖包-->
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-aop</artifactId>
     </dependency>
 </dependencies>

2, 创建切面,提供通知和切点

3, 测试

在这里插入图片描述
需求:统计每个方法的性能
OOP

package cn.tedu.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("time")
public class TimeController {
    //TODO 提供丰富的方法,并统计性能
    @RequestMapping("get")
    public void get(){
        long time = System.currentTimeMillis();//计时开始
        for (int i = 0; i < 1000; i++) {
            System.out.print(i);
        }
        long end = System.currentTimeMillis();//计时结束
        System.out.println();
        System.out.println(end-time);//性能
    }
    @RequestMapping("find")
    public void find(){
        long time = System.currentTimeMillis();//计时开始
        for (int i = 0; i < 10000; i++) {
            System.out.print(i);
        }
        long end = System.currentTimeMillis();//计时结束
        System.out.println();
        System.out.println(end-time);//性能
    }


}

AOP
问题: 每个方法都想统计性能,性能统计的代码需求写好多次.
解决方案:利用AOP,提取共性代码形成切面,并提供通知

package cn.tedu.spring;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Component //ioc的注解,交给spring完成new
@Aspect//spring整合了aspectj提供了面向切面编程的方式
//切面就是一个类,由通知(就是方法) 和 切点组成
public class TimerAspect {
    //切点:什么时候要触发通知的功能
                     //方法返回值    包名     类名 方法名(参数列表)
    @Pointcut("execution(* cn.tedu.controller.*.*(..))")
    public void pointcut(){}
    //这是前置通知,在调用目标方法前 触发执行
    @Before("pointcut()")
    public void beforeMethod(JoinPoint joinPoint){
        //TODO 检查缓存,权限,日志
        System.out.println("我是前置通知~~~");
    }
    //这是后置通知,在调用目标方法后 触发执行
    @After("pointcut()")
    public void afterMethod(JoinPoint joinPoint){
        //TODO 关流 ...
        System.out.println("我是 后置通知~~~");
    }
    //这是环绕通知,在调用目标方法前后 触发执行
    @Around("pointcut()")
    public Object aroundMethod(ProceedingJoinPoint joinPoint)
                throws Throwable {
        //TODO 事务管理 性能分析  日志管理
        //统计每个方法的执行性能
        long start = System.currentTimeMillis();//计时开始
        Object o = joinPoint.proceed();//找到目标方法并执行
        long end = System.currentTimeMillis(); //计时结束
        System.out.println("aop统计的结果表示,方法的耗时是:"+(end-start));
        return o ;//放行,执行目标方法
    }

}

测试AOP
就是打开浏览器,访问Controller层的各种方法,都会触发执行通知的功能.观察IDEA里控制台的输出语句就知道了.
http://localhost:8080/time/find
http://localhost:8080/time/get

笔记链接：https://blog.csdn.net/u012932876/category_11380363.html?spm=1001.2014.3001.5482

笔记补充：

1、概述：
Spring框架可以和其他技术无缝衔接
BeanFactory: bean工厂, spring框架认为所有类都是bean. 从bean工厂可以获取每个bean
IOC: 控制反转, 不需要程序员来创建对象了,交给Spring框架来管理对象(从初始化…销毁).程序员可以直接从 Spring框架中获取Bean的对象
DI: 依赖注入,使用Spring框架明确两个对象间的依赖关系
AOP: 面向切面编程,是一种思想,解决了OOP的不足

2、spring认为万物都是bean,只要你的类,交给spring框架,spring就能IOC
3、 IOC是控制反转:是指Spring框架会帮你创建对象,你来获取对象
4、 id属性是每个bean标签的唯一标识,class属性是用来指定类的全路径
5、 IOC底层Map的数据结构{类,类的对象}
6、junit单元测试方法:测试一段代码的结果@Test
7、1,读取配置文件–参数是配置文件的名字
8、获取对象–参数是配置文件里,bean标签的id的属性值
9、创建类, 并且一定要使用IOC注解(@Component @Controller @Service @Repository)
10、配置包扫描, 需要指定包的路径, 包的扫描范围越小越好, 合理的定范围就可以
11、IOC本质就是, 把你创建的类,Spring框架创建对象,存入Map集合里.
12、key是类名(首字母小写) value是类的对象(框架利用反射来创建的对象)
14、Map -> { “hello” , Class.forName(“Hello类的全路径”).newInstance() }
15、常用的IOC注解有四个: 功能都一样,都是交给spring框架创建对象
@Component @Service @Controller @Repository
16、用包扫描的机制,代替以前bean标签的配置
17、 IOC的本质是底层创建一个Map集合{类名的首字母变小写,类的对象}
18、区别:以前一个类必须配置对应的bean标签,
现在是只要在扫描的范围内而且使用了IOC注解的spring都会new
base-package:指定包的路径
包扫描的范围要适当的控制,范围越小扫描的速度越快
19、什么时候需要IOC? 需要把创建对象的权利交给Spring框架管理时
20、Ioc底层是map的结构

21、什么时候需要DI?当A类想用B类的属性或者方法时,直接把B类依赖注入到A类就可以

AOP
22、概述
是面向切面编程的思想.好处是: 把一些共性代码,提取形成切面,提供丰富的通知,聚焦了程序员的关注点,只关注业务本身.
1, 切面Aspect: 就是一个类
2, 通知Advice: 类里的方法,分类:
前置通知, 是指调用业务方法前会被执行的功能(适用于权限管理,缓存管理)
后置通知, 是指调用业务方法后会被执行的功能(适用于释放资源)
环绕通知, 是指调用业务方法的前后会被执行的功能(适用于事务管理,性能分析)
返回后通知, 是指调用业务方法并返回了结果后会被执行的功能
异常通知, 是指调用业务方法并抛出异常后会被执行的功能
3,切点PointCut: 触发通知执行的那个方法的时间点

23、问题: 每个方法都想统计性能,性能统计的代码需求写好多次.
解决方案:利用AOP,提取共性代码形成切面,并提供通知
24、切面就是一个类,由通知(就是方法) 和切点组成
25、切点:什么时候要触发通知的功能

多又多

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring

1.初识Spring框架时代变迁原始时代我们用一个jsp搞定一切，但如此开发大型项目时我们遇到了问题，前端美化的代码和后端的代码交织，代码中又有html、js、css样式，又有业务逻辑和数据库访问代码，杂乱不清晰，美工和开发打架。于是mvc分层架构封建时代出现，把我们写代码的地方硬性分成3个地方，Model层封装数据，View视图层页面展现，Controller控制层访问转发。代码之间的耦合度降低。概念有了，需要实际干活的。于是随着mvc分层概念的深入人心，业界涌现出很多实现框架，最著名的莫过于str
复制链接

扫一扫