spring框架

最新推荐文章于 2024-07-26 00:55:46 发布

飒宝贝是个程序媛

最新推荐文章于 2024-07-26 00:55:46 发布

阅读量155

点赞数 1

文章标签： spring aop

本文链接：https://blog.csdn.net/qq_17197453/article/details/105100874

版权

spring框架

1、 spring的理解(spring的核心定义及好处)

1)、Spring的开源的全栈式框架
2)、Spring有两大核心思想：IOC:控制反转(基于工厂模式)、AOP:面向切面编程(基于代理模式)
IOC:控制反转：指将对象的创建权，反转到Spring容器，主要解决耦合度问题；aop面向切面编程是抽取公用代码,在运行时,使用动态代理技术对方法进行增强,把抽取出来的代码(比如权限的控制，事务的控制，日志的记录等等)加到核心业务方法中,完善业务逻辑，另一方面也是对java面向对象编程的补充。
3)、它提供的事务管理机制，采用声明的方式来配置事务，从而在维护时无需改动源码，解决了程序硬编码的弊端。
4)、它可以整合其他时下流行的框架，使我们在管理项目时，更加清晰，明确。

2、IOC、DI的理解：

2.1、工厂模式、依赖注入的通俗理解：

（面向对象编程，自己new对象）原始社会里，几乎没有社会分工。需要斧子的人(调用者)只能自己去磨一把斧子(被调用者)。对应的情形为:Java程序里的调用者自己创建被调用者。
（工厂模式，由工厂创建）进入工业社会，工厂出现。斧子不再由普通人完成，而在工厂里被生产出来，此时需要斧子的人(调用者)找到工厂，购买斧子，无须关心斧子的制造过程。对应Java程序的简单工厂的设计模式。
（工厂创建后，需要时利用反射原理，在需要的时候取出）进入“按需分配”社会，在工厂生成斧子时告诉它，需要什么样的斧子(属性)。对应Spring的依赖注入。

2.2、控制反转的理解

IOC:控制反转：指将对象的创建权，反转到Spring容器
我们以前开发，在一个类中使用其他类对象的时候都是采用new的方式直接获取。这就造成了程序的耦合度非常高，一个类的运行，严重依赖于其他的类。
spring中的IoC控制反转就很好地解决了程序耦合度问题,将类的创建和依赖写到配置文件中,注入,实现控制反转的两种方式：依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。
依赖注入DI是指在BeanFactory创建对象的过程中，将对象依赖属性通过配置进行注入，如构造函数注入,set方法注入等等。
构造函数注入：创建类时没有setter方法，而是用有参构造，用constructor-arg标签。
set方法注入：生成get、set方法用property标签。
注解注入：实际上也是前两种注入方式，只是spring2.5之后使用注解配置，在spring配置文件中开启注解并配置要扫描的包，使用时用注解**@Resource和@Autowired**等。

2.1、DI依赖注入的三种类型(在配置文件中使用)：

 1)String与基本类型：value
 2)其他bean类型：ref
 3)复杂类型(集合 数组)：相同结构可以互换标签
   list结构：<array> <list> <set>
   map结构：<map> <props>

<property name="locations">
			<list>
				<value>classpath:db.properties</value>
				<value>classpath:mail.properties</value>
				<value>classpath:activemq.properties</value>
				 <value>classpath:redis.properties</value>
			</list>
		</property>

3、AOP(Aspect Oriented Programming):

3.1、代理模式的通俗定义(访问外网)：

远程代理：我们在国内因为GFW，所以不能访问 facebook，我们可以用（设置代理）的方法访问。访问过程是：
(1)用户把HTTP请求发给代理
(2)代理把HTTP请求发给web服务器
(3)web服务器把HTTP响应发给代理
(4)代理把HTTP响应发回给用户

3.2、面向切面编程的理解

面向切面编程是指把重复的公用代码抽取出来统一处理,在运行时,使用动态代理技术对方法进行增强,把抽取出来的代码(比如权限的控制，事务的控制，日志的记录等等)加到核心业务方法中,完善业务逻辑，另一方面也是对java面向对象编程的补充。
代理模式：
给某个对象提供一个代理对象，并由代理对象控制对于原对象的访问，即客户不直接操控原对象，而是通过代理对象间接地操控原对象。代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能
静态代理：
由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。
1)创建公共接口
2)创建一个目标类，一个代理类，均实现第一步的公共接口
3)创建代理对象，调用者调用目标对象时调用的是代理类的实现方法。
动态代理：
在程序运行时运用反射机制动态创建而成。
动态代理的两种实现方式：
1)基于接口(JDK提供的Proxy 类)：
(1)创建公共接口
(2)创建一个目标类，实现第一步的公共接口
(3)创建自己的事件处理器，继承InvocationHandle接口，重写invoke(…),在重写的InvocationHandler的invork()方法时执行目标对象的方法
@override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(“开启事务”);
// 执行目标对象方法
method.invoke(目标对象,args);
System.out.println(“提交事务”);
return null;
}

(4)测试，利用反射机制，调用Proxy.newProxyInstance(目标对象类加载器，目标对象实现的所有接口，事件处理器InvocationHandle)。
Proxy.newProxyInstance(target.getClass().getClassLoder(),target.getClass().getInterfaces(),handler);
2)cglib基于子类：第三方提供的开源项目
CGLIB 原理：动态生成一个要代理类的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。它比使用java反射的JDK动态代理要快。
CGLIB 底层：使用字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。
CGLIB缺点：对于final方法，无法进行代理。
(1)创建一个目标类
(2)创建自定义拦截器，实现MethodInterceptor,重写intercept(参数4)：前三个参数与invoke()相同,第四个是MethodProxy
(3)生成代理对象，Enhancer字节码增强器
代理对象=Enhancer.create(target.getClass(),自定义拦截器))

动态代理总结：基于接口的动态代理会生成接口的代理类,cglib会生成它的子类的代理类，如action中基于接口就是ModelDriven接口的代理类,只有getModel()方法,没有action的特有方法，而基于子类的cglib代理会生成action的子类的代理类,可以继承父类action的所有方法。

3.3、AOP里面的术语

— 方面（Aspect）：一个关注点的模块化，这个关注点实现可能另外横切多个对象。事务管理是J2EE应用中一个很好的横切关注点例子。方面用Spring的Advisor或拦截器实现。

— 连接点（Joinpoint）：程序执行过程中明确的点，如方法的调用或特定的异常被抛出。

— 通知（Advice）：在特定的连接点，AOP框架执行的动作。各种类型的通知包括“around”、“before”和“throws”通知。通知类型将在下面讨论。许多AOP框架包括Spring都是以拦截器做通知模型，维护一个“围绕”连接点的拦截器链。

— 切入点（Pointcut）：指定一个通知将被引发的一系列连接点的集合。AOP框架必须允许开发者指定切入点，例如，使用正则表达式。

— 引入（Introduction）：添加方法或字段到被通知的类。Spring允许引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现IsModified接口，来简化缓存。

— 目标对象（Target Object）：包含连接点的对象，也被称作被通知或被代理对象。

— AOP代理（AOP Proxy）：AOP框架创建的对象，包含通知。在Spring中，AOP代理可以是JDK动态代理或CGLIB代理。

— 编织（Weaving）：组装方面来创建一个被通知对象。这可以在编译时完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。

3.3.1、通知有哪些类型？

前置通知（Before advice）：在某连接点（join point）之前执行的通知，但这个通知不能阻止连接点前的执行（除非它抛出一个异常）。
返回后通知（After returning advice）：在某连接点（join point）正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。
抛出异常后通知（After throwing advice）：在方法抛出异常退出时执行的通知。
后置通知（After (finally) advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
环绕通知（Around Advice）：包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

4、BeanFactory接口和ApplicationContext接口有什么区别？

①ApplicationContext 接口继承BeanFactory接口，Spring核心工厂是BeanFactory ,BeanFactory采取延迟加载，第一次getBean时才会初始化Bean, ApplicationContext是会在加载配置文件时初始化Bean。
②ApplicationContext是对BeanFactory扩展，它可以进行国际化处理、事件传递和bean自动装配以及各种不同应用层的Context实现
开发中基本都在使用ApplicationContext, web项目使用WebApplicationContext ，很少用到BeanFactory
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource(“applicationContext.xml”));
IHelloService helloService = (IHelloService) beanFactory.getBean(“helloService”);

5、加载Spring容器,有三种方式：

1)ClassPathXmlApplicationContext类：实现ApplicationContext接口,它可以加载类路径下的spring配置文件
2)FileSystemXmlApplicationContext同样实现ApplicationContext,它用来读取系统中的配置文件
3)使用ContextLoadedListener监听器,以上两种每访问一次加载Spring容器,而监听器只会加载一次,
它只能加在webapps下的配置文件

BeanFactory体系结构：BeanFactory是延时加载策略,ApplicationContext采用立即加载策略(推荐)

6、bean的生命周期

大体分为四个过程：
1)BeanFactoryPostProcessor实例化
2)bean实例化,通过一些BeanFactoryPostProcessor进行依赖注入
3)BeanPostProcessor的调用：
Spring内置的BeanPostProcessor调用Bean实现的接口,
这些内置的BeanPostProcessor调用完后才会调用自己配置的BeanPostProcessor
4)Bean销毁：调用destory方法
在bean中配置属性init-method destory-method可以指定bean初始化及销毁的操作
单例的bean周期(dao service):
初始化：加载配置文件后,容器创建,bean创建
存活：
销毁：容器关闭 ApplicationContext接口没有关闭方法而它实现类ClassPath.
多例(action)
初始化：每访问一次,创建一次
存活：
销毁：垃圾回收机制
细节：Bean是可重用组件,实体类 dao service都是
当项目发布后,src目录消失,此时需要用类加载器加载src下的配置文件
Spring的xml配置ioc环境：4个必须包(beans core context el) 两个日志依赖

7、bean的作用范围(单例、多例5种)：

spring的bean作用域有5个，如下：
singleton：单例模式，当spring创建applicationContext容器的时候，spring会初始化所有的该作用域实例，加上lazy-init就可以避免预处理。
prototype：多（原）型模式，每次通过getBean获取该bean就会产生一个新的实例，创建后spring将不再对齐进行管理。
request：每次请求都会产生一个新的实例，和prototype不同的是，创建以后spring依然在监听。
session：每次会话，同上。
Global Session：全局
spring的controller默认是单例的，原因有二：
（1）为了性能：单例不用每次都创建
（2）不需要多例：只要controller中不定义属性，那么单例完全是安全可用的，如果定义了，那单例肯定会出现竞争访问；非要定义，则通过注解@Scope(“prototype”)，将其设置为多例模式。

8、bean的创建方式？有（构造器、静态工厂方法、实例工厂方法）三种

1：调用构造器创建Bean
1)：Bean实例实现类 Person.java
2)：配置文件beans.xml 配置标签
3)：使用
2：调用静态工厂方法创建Bean
1)：先创建一个Bean User类
2)：配置工厂类：定义静态方法getUser1()返回User对象
3)：XML配置：
<bean id="user1" class="ioc.service.UserFactory" factory-method="getUser1"></bean>
3：调用实例工厂方法创建Bean
*1)：先创建一个Bean User类
2)：配置工厂类：定义普通方法getUser2()返回User对象
3)：XML配置：

<bean id="userFactory" class="ioc.service.UserFactory"></bean>
 <bean id="user2" factory-bean="userFactory" factory-method="getUser2"></bean>

区别：
很明显，这三种方式最根本的区别还是创建方式的不同。
第一种，通过默认的无参构造方式创建，其本质就是把类交给Spring自带的工厂（BeanFactory）管理、由Spring自带的工厂模式帮我们维护和创建这个类。如果是有参的构造方法，也可以通过XML配置传入相应的初始化参数，这种也是开发中用的最多的。
第二种，通过静态工厂创建，其本质就是把类交给我们自己的静态工厂管理，Spring只是帮我们调用了静态工厂创建实例的方法，而创建实例的这个过程是由我们自己的静态工厂实现的，在实际开发的过程中，很多时候我们需要使用到第三方jar包提供给我们的类,而这个类没有构造方法，而是通过第三方包提供的静态工厂创建的，这是时候，如果我们想把第三方jar里面的这个类交由spring来管理的话，就可以使用Spring提供的静态工厂创建实例的配置。
第三种，通过实例工厂创建，其本质就是把创建实例的工厂类交由Spring管理，同时把调用工厂类的方法创建实例的这个过程也交由Spring管理，看创建实例的这个过程也是有我们自己配置的实例工厂内部实现的。在实际开发的过程中，如Spring整合Hibernate就是通过这种方式实现的。但对于没有与Spring整合过的工厂类，我们一般都是自己用代码来管理的。

9、常用注解：

表现层：
类：
@Controlle
@RequestMapping("/awb")
方法：
@RequestMapping(value = “get_awb”, method = RequestMethod.POST)

业务层：@service
@Transactional 事务控制，此注解可配置在接口类方法上,就近原则
其他：
@Component
@Autowired

10、Spring的核心类有哪些，各有什么作用？

BeanFactory：产生一个新的实例，可以实现单例模式
BeanWrapper：提供统一的get及set方法
ApplicationContext:提供框架的实现，包括BeanFactory的所有功能

11、DispatcherServlet

Spring的MVC框架是围绕DispatcherServlet来设计的，它用来处理所有的HTTP请求和响应。

12、WebApplicationContext

WebApplicationContext 继承了ApplicationContext 并增加了一些WEB应用必备的特有功能，它不同于一般的ApplicationContext ，因为它能处理主题，并找到被关联的servlet。

13、Spring里面applicationContext.xml文件能不能改成其他文件名？

可以修改，但是需要在web.xml中配置新的命名，否则默认applicationContext.xml
.
. org.springframework.web.context.ContextLoaderListener
.
. contextConfigLocation
. /WEB-INF/xyz.xml
.
.
.

14、Spring如何处理线程并发问题？ThreadLocal

Spring使用ThreadLocal解决线程安全问题
我们知道在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用域。就是因为Spring对一些Bean(如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等)中非线程安全状态采用ThreadLocal进行处理，让它们也成为线程安全的状态，因为有状态的Bean就可以在多线程中共享了。

15、Spring整合Junit

1)junit底层就是一个main函数,执行单元测试时, @Test注解的方法会执行,所以 @Test不能用于测试线程,
  因为单元测试在main中执行,主线程没走完,就不会执行其他线程
2)Spring整合Junit跟Spring整合Struts原理一样,原来执行junit的类并不知道spring
  解决: @RunWith(SpringJunit4ClassRunner.class)指定单元测试的main()
        @ContextConfiguration:用于指定spring配置文件的位置

飒宝贝是个程序媛

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring框架

spring框架1、 spring的理解(spring的核心定义及好处)1)、Spring的开源的全栈式框架2)、Spring有两大核心思想：IOC:控制反转(基于工厂模式)、AOP:面向切面编程(基于代理模式)IOC:控制反转：指将对象的创建权，反转到Spring容器，主要解决耦合度问题；aop面向切面编程是抽取公用代码,在运行时,使用动态代理技术对方法进行增强,把抽取出来的代码(比如...
复制链接

扫一扫