Spring

最新推荐文章于 2024-07-10 21:09:00 发布

Eirckiku

最新推荐文章于 2024-07-10 21:09:00 发布

阅读量91

点赞数 1

文章标签：架构 spring java

本文链接：https://blog.csdn.net/Eirckiku/article/details/123695230

版权

Spring是一款轻量级开源JavaEE框架

核心 IOC 控制反转，将创建对象过程交给Spring
AOP 面向切面，不该源代码增加新功能

特点：

1.方便解耦，简化开发
2.AOP编程支持
3.方便程序测试
4.方便个各种框架集成
5.方便进行事务操作
6.降低API开发难度

2.导入jar包

将基础jar包(beans,context,core,expression)放在lib文件目录下，
打开项目结构，模块，依赖，添加jar包(lib目录下)

3.使用xml配置文件管理类与方法

新建.xml的spring配置文件
id和类

<bean id="name" class="com.atguigu.spring5.User"></bean>

所在的包地址
->新建test测试类->使用注解@Test
->加载spring配置文件

ApplicationContext context = new ClassPathXmlApplication("文件名")

如在此目录下则可，不在则需完整路径
->使用context获取Bean对象，再创建对象

User user = context.getBean("user",User.class)

IOC概念和原理

1.概念

1.1.控制反转，把对象创建和对象之间的调用过程，交给Spring管理
1.2.目的：降低耦合度

2.底层原理

2.1.XMl解析，工厂模式，反射

3.IOC降低耦合度方法

3.1配置XML文件，在工厂类里:

public static UserDao getDao()
String classValue = class值
Class clazz = Class.forName(classValue)
return (UserDao) clazz.newInstance

4.IOC

可以用BeanFactory:IOC基本实现，Sprng内部接口，不推荐使用。加载配置文件你不会创建对象，只有获取对象的时候才会创建对象
ApplicationContext：BeanFactory的子接口，提供的功能更强大，一般由开发人员进行使用，获取配置文件的时候创建对象
IOC操作Bean管理

1.基于xml方式创建对象

<bean id="" class=""></bean>

1.1在配置文件中，使用bean标签添加对应属性，可以实现对象创建
1.2属性🆔唯一标识
class:类全路径
1.3创建对象也是默认无参构造方法

2.基于xml方式注入属性

2.1 DI：依赖注入，就是注入属性。DI是IOC的具体实现，
需要创建对象基础上完成

2.2 第一种注入方式：使用set方法注入

//使用property完成属性注入，name：类属性名称，value:注入的值

<bean id="book" class="com.atguitu.spring5.Book">
    <property name="bname" value="书名"></property>
</bean>

2.3 第二种注入方式：使用带参构造注入

假设类里已经有了带参构造方法

<bean id="orders" class="....orders">
			<constructor-arg name="属性名" value="注入值"></constructor-arg>
			..
</bean>

3.p名称空间注入

3.1 使用p名称空间注入，可以简化基于xml配置方式

<bean xmlns="....."
			  xmlns:p="http://www.springframework.org/schema/p"
			  xmlns:"...">
<bean id="book" class="com...." p:bname="值" p:bauther="值">

4.空值与对象值注入，与特殊字符

//空值
		在bean中<property name="变量名">
					<null/>	//将这个变量设置为null	
				</property>
		//特殊字符	<<南京>>
		<property name="变量名">
			<value>  <![CDATA[<<南京>>]]>   </value>
		</property>

5.注入属性外部bean，外部就是不属于此包下的类

//下面是创建一个对象，上面是利用ref将这个对象在service类里创建，就可以在service里调用userDao里的方法
<bean id="userService" class="com...">
		<property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com..."></bean>

6.注入属性内部bean和级联赋值内部就是属于此包下的类

6.1 在实体类之间表示一对多关系

<bean id="emp" class ="...">
	<property name="" value=""></property>//给普通属性赋值
		<property name="类名变量">
			<bean id="类名变量" class="...">
				<property name="变量" value="值"></property>
			</bean>
		</property>
</bean>

也可以:

，只不过需要调用dept的类里必须有dept对象的get方法

7.集合类型的属性注入

7.1 普通集合属性:

<property name="变量名">
		<array>
			<value>值</value>
			<value>值</value>
		</array>
</property>

7.2 list集合属性:

<property name="list">
	<list>
		<value>张三</value>
		<value>小三</value>
	</list>
</property>

7.3 map集合属性:

<property name="maps">
	<map>
		<entry key="JAVA" value="java"></entry>
		<entry key="PHP" value="php"></entry>
	</map>
</property>

7.4 set集合属性:

<property name="sets">
	<set>
		<value>MYSQL</value>
		<value>Redis</value>
	</set>
</property>

7.5 list集合注入对象: 在list中不再是value，而是ref，值为创建的多个bean

<property name="courseList">
	<list>
		<ref bean="course1"></ref>
		<ref bean="course2"></ref>
	</list>
</property>
<bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
	<property name="cname" value="Spring5kecheng"></property>
</bean>
<bean id="course2" class="com.atguigu.spring5.collectiontype.Course">
	<property name="cname" value="SpringMVCkecheng"></property>
</bean>

8.在bean里引入写好的工具方法数据：

xmlns:util="http://www.springframework.org/schema/util"
	再将最后一行，复制一行，将所有复制的beans改为util
<util:list id="booklist">
	<value>one</value>
	<value>two</value>
	<value>three</value>
</util:list>
<bean id="book" class="com.atguigu.spring5.collectiontype.Book">
	<property name="list" ref="booklist"></property>
</bean>

IOC操作Bean管理 FactoryBean

在配置文件中定义bean类型可以和返回类型不一样

1.
在MyBean类中实现接口FactoryBean的三个实现方法，并使用泛型，将getObject的返回对象为，在getObject中new 一个Course对象，return course.

2.bean单例多例

bean默认是单例，多次getBean获取一个对象。使用scope来设置为多例
scope=singleton 表示单实例对象， scope=prototype表示多实例对象
singleton在加载Spring配置文件的时候创建单例对象。
prototype在加载Spring配置文件的时候不创建对象，在getBean的时候创建对象

IOC操作Bean管理 bean生命周期

1.通过构造器创建bean实例(无参数构造)
2.为bean的属性设置值和对其他bean引用(调用set方法)
3.调用bean的初始化的方法(需要进行配置初始化的方法)
4.bean可以使用(对象获取到了)
5.当容器关闭时，调用bean的销毁方法，(需要进行配置销毁的方法)

IOC操作Bean管理 xml自动装配

1.在xml配置bean对象后面加 autowire
有两个值:byName和byType，byName按照名称自动注入,byType按照类型自动注入

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

引入依赖:

spring-aop-5.2.6.RELEASE.jar

四个注解:

@Component 、@Service 、@Controller 、@Repository 都是对对象创建

1.开启组件扫描

<context:component-scan base-package="包名"></context:component-scan>

扫描可以使用","来包含多个包名，也可以选择使用父类包名

2.@Component创建UserService对象，value值即为bean的id值

@Component(value = "userService")	//
public class UserService{
	....
}

3.此代码表示只会扫描这个包下的被 Controller 所注释的类

<context:component-scan base-package="包名" use-default-filters="false">
	<context:include-filter type="annotation"
				expression="org......Controller"/>
</context:component-scan>

4.此代码表示不会扫描这个包下的被 Controller 所注释的类

<context:component-scan base-package="包名">
		<context:exclude-filter type="annotation"
								expression="org......Controller"/>
</context:component-scan>

5.属性注入注解:

@AutoWired		@Qualifier	 @Resource

@AutoWired	根据属性类型进行自动装配
	将此注解写在属性上，不需要set方法
@Qualifier	根据属性名称进行注入，需要和AutoWired一起使用
	此注解表示根据名称注入	@Qualifier(value="被注解的类对象名称")
@Resource	可以根据类型注入，也可以根据名称注入
	@Resource直接根据类型注入。@Resource(name="") 根据名称注入
@Value		注入普通属性

AOP

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

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

AOP底层原理

AOP底层使用动态代理

(1) 两种情况动态代理

一、有接口情况，使用JDK动态代理

创建接口实现类的代理对象，增强类的方法

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

二、没有接口情况，使用CGLIB动态代理

创建子类的代理对象，增强类的方法

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

AOP(JDK动态代理)

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

使用java.lang.Object下的reflect.Proxy的static Object newProxyInstance()方法，方法里有三个参数:

第一个:ClassLoader loader, 类加载器

第二个:interfaces, 增强方法所在的类，这个类实现的，支持多个接口

第三个:invocationHandler，实现这个接口，创建代理对象，写增强方法

(1)创建接口，定义方法

public interface UserDao {

    public int add(int a,int b);

    public void update(String id);
}

(2)创建接口实现类，实现方法

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

    @Override
    public String update(String id) {
        return id;
    }
}

(3)使用Proxy类创建接口代理对象

public class JDKProxy {
    public static void main(String[] args) {
        UserDaoImpl userDao = new UserDaoImpl();
        Class[] interfaces = {UserDao.class};
        UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));

        System.out.println("resule"+dao.add(1,2));
    }

}
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术语

1.连接点

2.切入点

3.通知(增强)

4.切面

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

AOP操作

1.Spring框架一般基于AspectJ实现AOP操作

AspectJ不是Spring组成部分，独立于AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作

2.基于AspectJ实现AOP操作

(1)基于xml配置文件实现

(2)基于注解方式实现(常用)

3.在项目里引入AOP相关的依赖

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

4.切入点表达式

(1)切入点表达式作用，知道对哪个类里面的哪个方法进行增强

(2)语法结构

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

例: execution(*com.atguitu.dao.BookDao.add(…)) 一个切入点表达式，对add进行增强

execution(com.atguitu.dao.BookDao.(…))不写方法，在包名后写*号表示所有方法

execution(com.atguitu.dao..*(…)) 不写类名，不写方法名，对dao包里的所有类的所有方法

AOP操作(AspectJ注解)

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

//被增强的类
public class User {
    public void add(){
        System.out.println("add.......");
    }
}

2.创建增强类(编写增强逻辑)

//增强类
public class UserProxy {
    public void before(){
        System.out.println("add.....");
    }

}

3.进行通知的配置

(1)在spring配置文件中，开启注解扫描

<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.atguigu.spring5.aopanno"></context:component-scan>
</beans>

(2)使用注解创建User和UserProxy对象

//被增强的类
@Component
public class User {

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

//增强类
@Component
public class UserProxy {

    public void before(){
        System.out.println("add.....");
    }

}

(3)在增强类上面添加注解@Aspect

//增强类
@Component
@Aspect
public class UserProxy {

    public void before(){
        System.out.println("add.....");
    }

}

(4)在spring配置文件中开启生成代理对象

<!--    开启Aspect生成代理对象,使被@Aspect注解的类成为代理类-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

4.配置不同类型的通知

在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

@Component
@Aspect
public class UserProxy {
    //前置通知
    @Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void before(){
        System.out.println("before.....");
    }
    
    //最终通知
    @After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void after(){
        System.out.println("after......");
    }
    //后置通知
    @AfterReturning(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning.......");
    }
    //异常通知
    @AfterThrowing(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing.......");
    }
    //环绕通知
    @Around(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{

        System.out.println("环绕之前.......");

        //被增强的方法执行

        proceedingJoinPoint.proceed();

        System.out.println("环绕之后.......");
    }
}

5.公共切入点抽取

//相同切入点抽取
    @Pointcut(value="execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void pointdemo(){}
    //前置通知
    @Before(value = "pointdemo()")
    public void before(){
        System.out.println("before.....");
    }

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

(1)在增强类上面添加注解@Order(数字) 值越小优先级越高
User.add(…))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{

    System.out.println("环绕之前.......");

    //被增强的方法执行

    proceedingJoinPoint.proceed();

    System.out.println("环绕之后.......");
}

}


##### 5.公共切入点抽取

```java
//相同切入点抽取
    @Pointcut(value="execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void pointdemo(){}
    //前置通知
    @Before(value = "pointdemo()")
    public void before(){
        System.out.println("before.....");
    }