spring笔记

最新推荐文章于 2024-10-12 13:05:12 发布

Mr.Ma.01

最新推荐文章于 2024-10-12 13:05:12 发布

阅读量272

点赞数

分类专栏： javaEE 文章标签： spring java aop 设计模式

本文链接：https://blog.csdn.net/BennetMa/article/details/104078227

版权

javaEE 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

简介：

Spring是一个开源框架，它由Rod Johnson创建。

解决企业应用开发的复杂性而创建的。

Spring是一个轻量级的控制反转(IoC) 和面向切面(AOP) 的容器框架。

使现有技术更实用，本身是一个大杂烩，整合现有的框架技术

控制反转（IoC）：一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

面向切面（AOP）：允许通过分离应用的业务逻辑与系统级服务，进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

对事务的支持

对框架的支持

模块：
在这里插入图片描述

ioc-控制反转

1，对象由原程序本身创建，变为程序接收对象。
2，程序员主要集中于业务实现
3，实现service和dao的解耦工作，service层和dao层实现了分离
4，如果dao的实现发生改变，应用程序本身不用改变

总结：

1，以前对象是由程序本身来创建，使用spring后，程序变为被动接收spring创建好的对象，由主动编程变为被动接收，

2，ioc的实现是通过ioc容器来实现，ioc容器是一个bean工厂----BeanFactory

控制反转-----依赖注入

步骤：
1，导入相关jar包

<dependencies>
        <dependency>
            <!--核心工具类-->
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.3.19.RELEASE</version>
        </dependency>
        <dependency>
            <!--创建和管理bean，配置文件读写，进行IOC和DI的相关类-->
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.3.19.RELEASE</version>
        </dependency>
        <dependency>
            <!--扩展服务-->
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.19.RELEASE</version>
        </dependency>
       <dependency>
           	<!--切面编程，动态代理技术-->
        	<groupId>org.springframework</groupId>
        	<artifactId>spring-aop</artifactId>
        	<version>4.3.19.RELEASE</version>
    	</dependency>
        <dependency>
            <!--表达式语言-->
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>4.3.19.RELEASE</version>
        </dependency>
        <dependency>
            <!--通用日志工具包-->
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

2，编写配置spring文件

例：
在这里插入图片描述

使用ioc创建对象的三种方法

1.使用无参构造方法来创建：
在这里插入图片描述
2.使用有参构造方法来创建

根据参数下标来设置
在这里插入图片描述
根据参数名来设置

根据参数类型来设置

3，通过工厂方法来创建对象
静态工厂：

动态工厂：

配置文件详解

在这里插入图片描述
注：如果在 Bean 中未指定 id 和 name，那么 Spring 会将 class 值当作 id 使用。

bean作用域（scope属性）

singleton：单例-整个容器中只有一个对象实例默认是单例
对于无会话状态的 Bean （如 Dao 组件、 Service 组件〉来说是最理想的选择

prototype：原型-每次获取bean都产生一个新的对象如struts的action对象

request：每次请求时创建一个新对象

session：在会话范围内的一个对象

global session：只在protlet下有用，表示application

application：在应用范围中的一个对象

装配方式

依赖注入（XML装配）

依赖：指bean对象创建依赖于容器，bean对象的依赖资源。
注入：指bean对象依赖的资源由容器来设置和装配

Constructor-based 依赖注入

配置文件中需要使用＜bean＞元素的子元素＜constructor-arg＞来定义构造方法的参数，可以使用其 value 属性（或子元素〉来设置该参数的值。

见ioc创建对象

Setter-based 依赖注入

Setter-based DI 是在调用 no-argument 构造函数或 no-argument static工厂方法实例化 bean 之后，在 beans 上调用 setter 方法的容器来完成的

Spring 首先会调用 Bean 的默认构造方法来实例化 Bean 对象，然后通过反射的方式调用 setter（）方法来注入属性

Bean 类必须提供一个默认的元，参构造方法。
Bean 类必须为需要注入的属性提供对应的 setter（）方法

Spring 配置文件中使用＜bean＞元素的子元素＜property＞来为每个属性注入值

直值(primitives，Strings 等)注入

<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <!-- results in a setDriverClassName(String) call -->
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
    <property name="username" value="root"/>
    <property name="password" value="masterkaoli"/>
</bean>

bean注入

<bean id="exampleBean" class="examples.ExampleBean">
    <property name = "name" ref = "anotherExampleBean"/>
</bean>
<bean id="anotherExampleBean" class="examples.AnotherBean"/>

Array，List，Set，Map和Properties注入

<bean id="moreComplexObject" class="example.ComplexObject">
	<property name="books">
		<array>
			<value>test1</value>
		</array>
	</property>
    <!-- results in a setAdminEmails(java.util.Properties) call -->
    <property name="adminEmails">
        <props>
            <prop key="administrator">[emailprotected]</prop>
            <prop key="support">[emailprotected]</prop>
            <prop key="development">[emailprotected]</prop>
        </props>
    </property>
    <!-- results in a setSomeList(java.util.List) call -->
    <property name="someList">
        <list>
            <value>a list element followed by a reference</value>
            <ref bean="myDataSource" />
        </list>
    </property>
    <!-- results in a setSomeMap(java.util.Map) call -->
    <property name="someMap">
        <map>
            <entry key="an entry" value="just some string"/>
            <entry key ="a ref" value-ref="myDataSource"/>
        </map>
    </property>
    <!-- results in a setSomeSet(java.util.Set) call -->
    <property name="someSet">
        <set>
            <value>just some string</value>
            <ref bean="myDataSource" />
        </set>
    </property>
</bean>

Null 和空 string 值注入

<bean class="ExampleBean">
    <property name="email">
        <null/>
    </property>
</bean>
<bean class="ExampleBean">
    <property name="email" value=""/>
</bean>

p-namespace注入

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

    <bean name="classic" class="com.example.ExampleBean">
        <property name="email" value="[emailprotected]"/>
    </bean>

    <bean name="p-namespace" class="com.example.ExampleBean"
        p:email="[emailprotected]"/>
</beans>

c-namespace注入

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:c="http://www.springframework.org/schema/c"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="bar" class="x.y.Bar"/>
    <bean id="baz" class="x.y.Baz"/>

    <!-- traditional declaration -->
    <bean id="foo" class="x.y.Foo">
        <constructor-arg ref="bar"/>
        <constructor-arg ref="baz"/>
        <constructor-arg value="[emailprotected]"/>
    </bean>

    <!-- c-namespace declaration -->
    <bean id="foo" class="x.y.Foo" c:bar-ref="bar" c:baz-ref="baz" c:email="[emailprotected]"/>

</beans>

Annotation 装配

常用注解：
在这里插入图片描述

自动装配

简化spring配置文件

配置bean时，可以配置bean的auto wire属性，来指定装配类型

no 不使用自动装配
byname 根据名称（set方法名来的）去查找相应的bean
bytype 根据类型进行自动装配 不管bean的id 同一种类型的bean只能有一个
constructor 当通过构造器注入实例bean时 适用bytype的方式装配构造方法

可以配置全局的自动装配类型，在头部default-autowire
推荐不使用自动装配，而使用注解（annotation）

AOP—面向切面编程

aop在spring中提供声明式服务，允许用户实现自定义切面
在不改变原有代码的情况下，增加新的功能
1，传统编程模式
在这里插入图片描述
2，aop编程模式

aop的好处：

使得真实角色处理业务更纯粹，不再关注一些公共的事情
公共的业务由代理来完成----实现业务的分工
公共业务发生扩展时变得更加集中和方便

名词解释

Aspect （切面）：切面通常是指封装的用于横向插入系统功能（如事务、日志等）的类，该类妥被 Spring 容器识别为切面，需要在配置文件中通过＜bean＞元素指定。

Joinpoint （连接点）：在程序执行过程中的某个阶段点，它实际上是对象的一个操作，例如方法的调用或异常的抛出。在 SpringAOP 中，连接点就是指方法的调用。

Pointcut （切入点）：是指切面与程序流程的交叉点，即那些需要处理的连接点。通常在程序中，切入点指的是类或者方法名，如某个通知要应用到所有以 add 开头的方法中，那么所有满足这一规则的方法都是切入点。

Advice （通知增强处理）： AOP 框架在特定的切入点执行增强处理，即在定义好的切入点处所要执行的程序代码。可以将其理解为切面类中的方法，它是切面的具体实现。

Target Object （目标对象）：是指所有被通知的对象，也称为被增强对象。如果 AOP 框架采用的是动态的 AOP 实现，那么该对象就是一个被代理对象。

Proxy （代理）：将通知应用到目标对象之后，被动态创建的对象。

Weaving （织入）：将切面代码插入目标对象上，从而生成代理对象的过程

spring实现aop----aopAPI

spring aop 就是将公共的业务（如日志，安全等）和邻域业务结合。当执行邻域业务时，将会把公共业务加进来。实现公共业务的重复利用。邻域业务更加纯粹。程序员专注于邻域业务。其本质是动态代理

实现spring提供的接口

1，前置通知
在这里插入图片描述
2，后置通知

spring配置文件（总）

自定义类来实现

Log.java
在这里插入图片描述
配置文件

通过注解来实现

log.java
在这里插入图片描述

配置文件

基于XML的声明式AspectJ

切面
在这里插入图片描述
切入点

通知

//定义切面bean
<bean id="myAspect " class= "corn.smm.aspectj.xmI.MyAspect" />
<aop : config>
//配置切面
	<aop : aspect id=” aspect” ref= "myAspect” >
		//配置切入点
		<aop :pointcut expression="execution (* com.ssm.aspectj.*.*（..））"id＝"myPointCut"/>
//第1个*表示的是返回类型,使用*代表所有类型;com.ssm.jdk 表示的是需要拦截的包名，后面第 2 个*表示的是类名，使用*代表所有的类；第3个*表示的是方法名，使用*表示所有方法；后面的（）表示方法的参数，其中的“..＂表示任意参数。需要注意的是，第1个*与包名之间有一个空格
		// 配置通知
		// 前置通知
		<aop :before method="myBefore " pointcut-ref＝ "myPointCut" />
		//后置通知
		<aop : after-returning method= "myAfterReturning"
				pointcut-ref="myPointCut " returning＝ "returnVal" />
		//环绕通知
		<aop : around method="rnyAround" pointcut-ref="myPointCut" />
		//异常通知 
		<aop :after- throwing rnethod= "myAfterThrowing"
				pointcut-ref="myPointCut " throwing=" e "/>
		//最终通知
		<aop : after method="rnyAfter " pointcut-ref="myPointCut" />
	</aop : aspect>
</aop:config>