Java框架-Spring-知识点概括

最新推荐文章于 2024-05-01 05:43:39 发布

孤独的侠客

最新推荐文章于 2024-05-01 05:43:39 发布

阅读量427

点赞数 1

分类专栏：开发语言-Java spring

本文链接：https://blog.csdn.net/chenyunqiang/article/details/80762044

版权

开发语言-Java 同时被 2 个专栏收录

30 篇文章 0 订阅

订阅专栏

spring

7 篇文章 0 订阅

订阅专栏

IOC

传统的资源查找方式要求组件向容器发起请求来查找资源，作为回应，容器适时的返回资源；而IOC容器会主动地将资源推送给它所管理的组件，组件要做的仅是选择一种合适的方式来接受资源即可。

DI

DI是IOC的另一种表述方式，即组件以一些预先定义好的方式(如setter方法)接受来自容器的资源注入。

BeanFactory与ApplicationContext

1. Spring提供的两种IOC窗口，BeanFactory是面向底层，而几乎所有的应用场景都是用ApplicationContext.

2. ApplicationContext的几个主要实现类是：ClassPathXmlApplicationContext, FileSystemXmlApplicationContext

3. ApplicationContext在初始化上下文时就实例化所有的单例Bean.

Spring常用的两种依赖注入的方式

1. 属性注入: 通过setter方法注入，使用标记，指定name与value

2. 构造器注入: 通过构造方法注入，使用标记，指定value，index,

引用其它Bean

1. 在属性或构造器参数通过元素或ref属性对Bean进行引用

<property name = "service" ref="service"></property>
<constructor-arg ref="service">

2. 内部Bean: 在标签下定义Bean

<property name="service">
    <bean id = "service" class="***">
    ...
</property>

3. 使用元素标签注入null值

<constructor-arg><null/></constructor-arg>

4. 级联属性: 对引用的对象的属性进行注入

<constructor-arg ref="car">
<property name="car.maxspeed" value="220">

5. 集合属性: `<list>, <set>, <map>`

<property name="cars">
    <list>
        <ref bean="car1"/>
        <ref bean="car2"/>
        <bean id="car3">...
    </list>
</property>
<property name="cars">
    <map>
        <entry key="key1" value-ref="car1"/>
        <entry key="key2" value-ref="car2"/>
    </map>
</property>
<property name="properties">
    <props>
        <prop key="name">crx</prop>
        <prop key="age">18</prop>
    </props>
</property>

Bean自动装配

可以对Bean设置属性autowire，可以取值”byName”或”byType”。这样会自动对Bean的属性对象进行注入。但是不推荐使用，因为不够明确清晰。

Bean配置的继承

1. 可以配置bean的parent属性指定继承关系，这种继承不代表两个bean之间有什么关系，而仅仅是复用了父bean的配置信息而已，比如继承了属性配置。

<bean id="address" class="main.Address" p:city="beijing" p:street="wangjing" />
<bean id="address2" p:street="huilongguang" parent="address" />

2. bean可以被设置abstract=true，这样该bean不会被容器实例化，只能用于被其它bean继承。若一个bean的class属性没有指定，则该bean必须被声明为抽象bean.

Bean的依赖

1. 可以对bean设置depends-on属性，来指定bean的前置依赖bean,前置依赖bean会在该bean实例化之前被创建好

2. 可以指定多个前置bean,通过逗号隔开

Bean的作用域

1. 给bean可以配置scope属性，可以取值singleton, prototype, (request, session)

2. 其中singleton是默认的作用域，容器里只有一个bean实例

3. prototype在每次调用getBean方法时都会返回一个新的实例

4. request, session仅适用于WebApplicationContext环境

<bean id="car" class="Demo.Car" scope="prototype">
    <property name="brand" value="Audi" />
</bean>

使用外部属性文件

1. 通过在spring配置文件里使用`<context:property-placeholder>`来导入属性文件: `<context:property-placeholder location="classpath:db.properties" />`

2. 通过`${var}`来引用外部属性文件中的变量:

<context:property-placeholder location="classpath:db.properties" />
<bean id="datasource" class="...DataSource">
    <property name="user" value="${user}" />
    <property name="password" value="${password}" />
</bean>

db.properties文件:
user=root
password=123456

SpEL

1. 使用#{…}表达

2. SpEL为bean的属性进行动态赋值提供了方便

3. 调用bean的方法，引用bean的属性，计算表达式的值

<bean id="car" class="">
    <property name="brand" value="Audi" />
</bean>
<bean id="person" class="">
    <property name="car" value="#{car}" />
</bean>

IOC容器中Bean的生命周期

1. 通过对bean设置init-method与destory-method来让bean在实例化之后和销毁后执行特定的动作。

<bean id="car" class="...Car" init-method="init" destory-method="destory">
    <property name="brand" value="Audi" />
</bean>

2. 如果在初始化方法前后还想对Bean进行额外的处理，则可以创建Bean的后置处理器。注意后置处理器是对IOC容器中所有的Bean实例进行逐一处理。后置处理器需要实现BeanPostProcessor接口。

public class MyBeanPostProcessor implements BeanPostProcessor{
    @override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException{
        ...
    }

    @override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException{
        ...
    }
}

在Bean配置文件里配置上该Bean
<bean class="...MyBeanPostProcessor" />

3. 结合1，2，我们看下IOC容器对Bean的生命周期进行管理的过程和顺序:

a. 构造函数
b. 为bean的属性赋值
c. 将bean实例传递给后置处理器的postProcessBeforeInitialization方法
d. 调用bean的初始化方法
e. 将bean实例传递给后置处理器的postProcessAfterInitialization方法
f. Bean可以使用了
g. 当容器关闭时，调用bean的销毁方法

通过工厂方法创建Bean

1. 静态工厂方法

指定factory-method，并通过传递参数

2. 实例工厂方法

指定factory-bean与factory-method，并通过传递参数

FactoryBean创建Bean

1. 需要继承FactoryBean<>接口，重写getObject, getObjectType, isSingleton方法；

2. 配置参数时class为FactoryBean的全类名，Property是配置FactoryBean的属性，但实际返回的实例是FactoryBean的getObject方法返回的实例；

基于注解配置Bean

1. Spring能够从classpath下自动扫描，侦测和实例化具有特定注解的组件。

2. 特定组件包含：@Component, @Respository, @Service, @Controller

3. 在spring配置文件中声明自动扫描范围: `<context:component-scan base-package="com.test.spring.bean" resource-pattern="autowire/*.class" />`

4. 下可以通过配置多个和子节点来进行过滤配置；

组件装配

1. 还会自动装配具有@Autowired注解的属性。通过该注解完成组件的自动装配。

2. 例如通过@Controller注解的controller会引用service，则将该service属性标注为@Autowired，这样会进行自动装配。如果涉及到接口，需要指定特定的子类，可以用@Qualifier:

@Controller
publice class UserController{
@Autowired
private UserService userService;
...
}

融合配置文件

代理模式

1. 代理模式: 使用一个代理Proxy将目标对象Target进行包装，然后用该代理对象取代原目标对象，代理对象可以在目标对象的基础上新增功能；

2. 静态代理模式: proxy中引用target，然后对target的方法进行扩展；

3. 动态代理模式: 通过jdk的反射机制实现，主要类是reflect包里的Proxy对象的newProxyInstance方法，还有继承InvocationHandler接口来实现。

4. Cglib代理模式: 相对于jdk代理的优点就是target目标对象不用一定要继承某interface了。spring的aop就是如此。

AOP相对于代理模式

1. 横切关注点被模块化到特殊的对象(切面)里

AOP的好处

1. 每个事务的逻辑位于一个位置，代码不分散，便于维护和升级

2. 业务模块更简洁，只包含核心业务代码

AOP的术语

1. 切面(Aspect):

2. 通知(Advice):

3. 目标(Target):

4. 代理(Proxy):

5. 连接点(Joinpoint):

6. 切点(Pointcut): 表示要切入的时机

AspectJ

1. Java社区最流行的AOP框架

2. 要使用AspectJ，必须引入AspectJ类库

3. 要启用AspectJ注解支持，需要在Bean配置文件中定义`<aop:apectj-autoproxy>`

4. 切面是一个带有@Aspect注解的Java类

5. 通知是被标注为@Before, @After, @AfterRunning @AfterThrowing @Around的Java方法

6. 切入点表达式:

@Before("execution(* ArithmeticCalculator.add(..))")表示执行add方法前切入
@Before("execution(public * ArithmeticCalculator.*(..))")表示所有公有方法执行前

7. 合并切入点表达式

@Pointcut("execution(* *add(int,**)) || execution(* *.sub(int, **))")
private void loggingOperation(){}

@Before("loggingOperation()")

8. 在切入方法参加中声明连接点，可以访问当前连接点的细节

@Before("execution(* *.*(..))")
publict void logBefore(JoinPoint joinPoint){
    log.info("the mothod" + joinPoint.getSignature().getName()) + "begins with " + Arrays.toString(joinPoint.getArgs()));
}

9. 在返回通知中访问连接点的返回值

@AfterReturning(pointcut="execution(* *.*(..))", returning="result")
public void logAfterReturing(JoinPoint joinPoint, Object result){

}

10.在AfterThrowing通知中捕获连接点的异常信息

@AfterThrowing(pointcut="execution(* *.*(..))", throwing="e")
publict void logAfterThrowing(JoinPoint joinPoint, Exception e){

}

11. 切面的优先级: 在同一个连接点上应用不止一个切面时，可以通过@Order注解来指定优先级

用基于XML的配置声明切面

大概了解下

Spring对JDBC的支持

1. JdbcTemplate:线程安全的、单例。可以将jdbcTemplate注入到DAO中。

2. JdbcDaoSupport

Spring中的事务管理

1. 通过AOP框架支持声明式事务管理，将事务管理代码从业务方法中分享出来。

2. 当然也支持编辑式事务管理，即需要在业务方法中自己做事务管理来控制事务提交和回滚。

3. 可以通过xml配置的方式: a. 声明事务管理器; b. 声明事务通知; c. 声明advisor来将通知与切入点关联;

4. 通过@Transactional注解来标注事务方法；

5. 如果在一个类标注为@Transactional，则该类中的所有公共方法都会被定义成支持事务处理的；

6. 在Bean配置中启用元素来支持事务管理的注解；

7. 在Bean中需要配置transactionManager；

8. 事务的传播？A事务方法中包含B事务方法时，传播的方式影响A事务的结果；可以通过在@Transactional的progagation设置传播类型；

9. 事务的隔离? 事务的隔离有几种级别，但需要底层数据库引擎的支持，比如mysql支持全部4种级别；而oracle只支持read_commited, serializable两种；

10. 通过在@Transactional的isolation属性中https://aone.alibaba-inc.com/设置隔离级别。

11. 设置回滚事务属性，即在遇到什么错误时回滚或不回滚。通过在@Transactional的rollbackFor和noRollbackFor属性中设置。

12. 设置超时和只读事务属性。通过设置readOnly和timeout属性。

@Transactoinal(propagation=Propagation.REQUIRES_NEW,
   isolation=Isolation.READ_COMMITTED,
   rollbackFor={IOException.class,SQLException.class},
   noRollbackFor=ArithmeticException.class，
   timeout=30,
   readOnly=true)

Spring融合Hibernate

1. SessionFactory: 可以利用LocalSessionFactoryBean工厂Bean来实例化SessionFactory，需要指定configLocation属性来加载Hibernate配置文件。可以指定dataSource属性、mappingResources属性、hibernateProperties。

2. HibernateTemplate === JdbcTemplate

3. HibernateDaoSupport === JdbcDaoSupport

4. HibernateTransactionManager === DataSourceTransactoinManager

5. 实例化Template与TransactionManager时需要指定SessionFactory

Spring整合Struts2

1. 将Action实例交给Spring容器来负责生成、管理；

孤独的侠客

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java框架-Spring-知识点概括

IOC传统的资源查找方式要求组件向容器发起请求来查找资源，作为回应，容器适时的返回资源；而IOC容器会主动地将资源推送给它所管理的组件，组件要做的仅是选择一种合适的方式来接受资源即可。DIDI是IOC的另一种表述方式，即组件以一些预先定义好的方式(如setter方法)接受来自容器的资源注入。BeanFactory与ApplicationContext1. S...
复制链接

扫一扫