Spring的核心API

最新推荐文章于 2024-04-17 14:39:37 发布

Xiong2219376948

最新推荐文章于 2024-04-17 14:39:37 发布

阅读量744

点赞数

文章标签： spring

本文链接：https://blog.csdn.net/weixin_47994966/article/details/118582727

版权

1.applicationContext

作用：Spring提供的ApplicationContext这个工厂，用于对象的创建。

好处：解耦合。

接口类型：

非web环境下：ClassPathXmlApplicationContext

web环境下：XmlWebApplicationContext

2.重量级资源

①ApplicationContext工厂的对象占用大量内存。

②不会频繁的创建对象：一个应用只会创建一个对象。

③ApplicationContext工厂：一定是线程安全的（支持多线程并发访问）

3.程序开发步骤

①创建类型

②配置文件的配置 applicationContext,xml

③通过工厂类，获得对象

ApplicationContext

|--- ClassPathXmlApplicationContext

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

Person person = context.getBean("person",Person.Class)

4.注入（Injection）

①.什么是注入

通过Spring工厂及配置文件，为所创建的对象的成员变量赋值。

②.为什么要注入

通过编码方式，为成员变量进行赋值，存在耦合。

③如何进行注入【步骤开发】

类的为成员变量提供set、get方法

配置Spring的配置文件

④注入的好处： 解耦合

⑤针对不同类型的成员变量，再<property>标签，需要嵌套其他标签

1.JDK内置类型

1.1String + 8 种基本类型：<value> 值 <value>

1.2 数组：
           <property name="emails">
                     <list>
                          <value>com.cmsim</value>
                          <value>com.cmsis</value>
                          <value>com.cmsid</value>
                     </list>
           </property>
1.3 set集合
           <property name="tels">
                     <set>
                        <value>10086</value>
                        <value>15023874241</value>
                        <value>1502387</value>
                     </set>
          </property>
1.4 List集合
          <property name="address">
                 <list>
                   <value>park</value>
                   <value>park3</value>
                   <value>park2</value>
                   <value>park1</value>
                 </list>
          </property>           
          <list>
             <ref bean=""></ref>
             <set></set>
         </list>
1.5 map集合
        <property name="qqs">
                  <map>
                    <entry>
                      <key>
                         <value>sums</value>
                     </key>
                      <value>sim</value>
                    </entry>
                  
                    <entry>
                     <key>
                       <value>ss</value>
                     </key>
                    <value>ee</value>
                  </entry>
                 </map>
        </property>
1.6 properties
        <property name="properties">
            <props>
                <prop key="username">root</prop>
            </props>
        </property>
   2.用户自定义类型

第一种注入方式

①为成员变量提供set、get方法，

②配置文件中进行注入（赋值）

③存在问题：

配置文件代码冗余

被注入的对象，多次创建，浪费jvm内存资源

第二种注入方式

使用 <ref>标签

⑥构造注入

Spring调用构造方法，通过配置文件，为成员变量赋值

开发步骤：

提供有参构造器

Spring的配置文件

5.反转控制(IOC Inverse of Control)

①控制：对于成员变量赋值的控制权

②反转控制：把对于成员变量赋值的控制权，从代码中反转到Spring工厂和配置文件中完成

好处: 解耦合

③底层实现：工厂设计模式

6.依赖注入（Dependency Injection DI）

①注入：通过Spring的工厂及配置文件，为对象（bean,组件）的成员变量赋值

②依赖注入：当一个类需要另一个类时，就意味着依赖，一旦出现依赖，就可以把另一个类作为本类成员变量，最终通过Spring进行注入（赋值）。

7.Spring工厂创建复杂对象

7.1 实现FactoryBean接口

①开发步骤

实现FactoryBean接口

Spring配置文件的配置

②细节（加&号）

A.如果就想获得FactoryBean类型的对象 getBean("&conn)，获得就是ConnectionFactoryBean对象。

B.isSingleton

返回true只会创建一个复杂对象

返回flase每一次都会创建新的对象（对于连接对象不能被共用，应该每次创建新的对象）

7.2 实例工厂

7.3 静态工厂

8.控制Spring工厂创建对象的次数

①控制简单对象的创建次数
       <bean id="person" class="Person" scope="singleton|prototyoe"/>
singleton:只会创建一次简单对象（默认）

prototype：每次都会创建新的对象

②控制复杂对象创建次数

FactoryBean{

isSingleton(){

return true 只会创建一次

return false 每一次都会创建新的

}

}

③什么样的对象只创建一次

SqlSessionFactory

DAO

Service

④什么样的对象每一次都要创建新的

Connection

SqlSession

9.对象生命周期

① 什么是对对象的生命周期

指的是一个对象创建、存活、消亡的一个完整过程

② 生命周期的3个阶段

A.创建阶段

Spring工厂何时创建对象

scope="singleton"

Spring工厂创建的同时，对象的创建

注意：标签中加入 lazy-init="true"属性： Spring工厂会获得对象的同时，创建对象。

   <bean id="person" class="Person" scope="singleton" lazy-init="true">

scope="prototype"

   Spring工厂会获得对象的同时，创建对象



B.初始化阶段

Spring工厂创建完成对象后，调用对象的初始化方法，完成对象的初始化操作

A.初始化方法调用提供：程序员根据需求，提供初始化方法，完成对应的初始化操作

B.初始化方法调用：Spring工厂进行调用

   方式一： InitialzingBean接口

在afterProperitesSet()方法中完成初始化工作。

方法二：对象中提供一个普通的方法

public void myInit( ){

    }

<bean id="person" class="Person" scope="singleton" init-method="">

细节分析 ：

A.如果一个对象即实现InitializingBean 同时提供了普通的初始化方法调用顺序：

InitalizingBean

普遍初始化方法

B.属性注入一定发生在初始化操作之前

C.什么叫做初始化操作

资源的初始化：数据库、IO 、网络 .......

C.销毁阶段

Spring销毁对象前，会调用对象的销毁方法，完成销毁操作

① Spring什么时候销毁所创建的对象

context.close();

② 调用方法：程序员根据自己需求，定义销毁方法，完成销毁操作

方式一：实现DisposebleBean

    在destory()方法中完成销毁工作（资源释放）。

方式二：定义一个普通方法，在spring配置文件对应bean标签中加入 destroy-method=""属性

细节分析：

A. 销毁方法的操作只适用于scope=“singleton”

生命周期总结：

10.配置文件参数化

①开发步骤：

a.提供一个小的配置文件（.properties）
                      jdbc.driverClassName=com.mysql.cj.jdbc.Driver      
                      jdbc.url=jdbc:mysql://localhost:3306/mysql
                      jdbc.username=root
                      jdbc.password=123456
b.Spring的配置文件与小配置文件进行整合

11.自定义类型转换器

①类型转换器

作用： Spring通过类型转换器把配置文件中字符串类型的数据，转换成了对象中成员变量对应类型的数据，进而完成了注入。

②自定义类型转换器

原因：当Spring内部没有提供特定类型转换器时，而程序员在应用时还需要使用，那么就需要程序员自定义转换器。

步骤：

a.实现converter接口

b.Spring配置文件中进行注册

12.后置处理bean

BeanPostProcessor作用：对Spring工厂所创建的对象，进行在加工（Aop底层实现原理）

步骤：

a.实现BeanPostProcessor规定接口中的方法：

//作用：Spring创建好对象，并进行注入后，可以运行before方法进行加工

Object postProcessBeforeInitiallization(Object bean,String beanName)

//作用：Spring执行完对象的初始化操作后，可以运行After方法进行加工

Object postProcessAfterInitiallization(Object bean,String beanName)

b.Spring的配置文件中进行配置

<bean class="beanpost.MyBeanPostProcessor" id="beanPostProcessor"/>

13.Spring基于注解开发

步骤：

   在Spring配置文件中加入<context:component-scan base-package=""/>

作用：让Spring框架在设置包及其子包中扫描对应注解，使其生效

对象创建相关注解：

① @Component：替换原有Spring配置文件中的<bean>标签

细节：

a.显示指定工厂创建对象的id @Component（“xxxx”）

   b.Spring配置文件覆盖注解配置内容 id值 class的值要和注解中的设置保持一致

   c.衍生注解 @Repostory @Service @Controller 使用方法和@Component一样

② @Scope：控制简单对象创建次数

③ @Lazy：延迟创建单实例对象

生命周期注解：

① @PostConstruct: 对象创建后初始化相关方法

② @PreDestroy: 工厂销毁前调用的方法

注入注解：

a.用户自定义类型注入

1.@Autowired

细节：

①基于类型注入

② Autowired注解放置位置：

a.放置在对应成员变量的set方法上，调用set方法注入

b.直接把注解放置在成员变量之上，Spring通过反射直接对成员变量进行注入（赋值）

2. @Autowired + @Qualifier

①基于名字注入：注入对象地id值必须与Qualifer注解中设置的名字相同。

3. @Resouce（name=“xxxxxxxxx”）基于名字进行注入

注意：如果应用Resource注解时，名字没有配对成功，会按照类型进行注入

b.JDK类型

1. @Value注解

方式一：读取xxxx.properties文件进行属性注入

步骤：

①在Spring框架中配置<context: property-placeholder location="">标签

(也可以使用@PropertySource注解代替)

② 在对应类属性上加入@Value（"${key}"）

方式二: 直接在属性上加@Value（"xxxxxx"）属性值为xxxxxx

注意细节：

①@Value注解不能应用在静态变量上

②不能注入集合类型

扫描注解：@ComponentScan(注意配置在有@Configuration类上)

<context:component-scan base-package="com.example"/> （当前包及子包）

①排除方式

<context:component-scan base-package="com.example">

<context:exclude-filter type="" expression=""/> //可叠加使用

<context:exclude-filter type="" expression=""/> //可叠加使用

type: assignable :排除特点类型

annotation：排除特点的注解

aspectj: 切入表达式

</context:component-scan>

②包含方式 //让Spring默认注解扫描方式失效

<context:component-scan base-package="com.example" use-default-filter="false">

<context:include-filter type="" expression=""/> //可叠加使用

<context:include-filter type="" expression=""/> //可叠加使用

type: assignable :排除特点类型

annotation：排除特点的注解

aspectj: 切入表达式

</context:component-scan>

配置文件注解

①使用@Configuration代替Spring配置文件

变化：

1.创建工厂代码：ApplicationContext ctx = new AniotationConfigApplicationContext( );

2.指定配置文件

方式一：指定配置bean的class ： ApplicationContext ctx = new AniotationConfigApplicationContext( Config.class);

  方式二：指定配置bean所在路径：ApplicationContext ctx = new AniotationConfigApplicationContext( "com.example");

② @Bean ： 注解在 @Configuration中使用，等同于xml配置文件中的<bean>标签

自定义id值： @Bean("id")

加@Scope（"singleton|prototype"）

完成对象创建步骤：



配置类文件与Spring配置文件整合：在配置类上加入@ImportResource("xxx.xml")

@Import(xxx.class)  在配置类上加入可以实现多个configration配置文件类整合

14.多种创建对象方式的选择

配置优先级：@Componnet及其衍生注解 < @Bean < 配置文件bean标签

优先级高的配置覆盖优先级低的配置

15.事务

a.事务的传播特性：指的是一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。

b.7种事务隔离级别：

1）REQUIRED：默认事务类型，如果没有，就新建一个事务；如果有，就加入当前事务，适合绝大多数情况。

2）REQUIRES_NEW:如果没有，就新建一个事务；如果有，就将当前事务挂起

3）NESTED:如果没有，就新建一个事务；如果有，就在当前事务中嵌套其他事务

4）SUPPORTS：如果没有，就以非事务方式执行；如果有，就使用当前事务

5）NOT_SUPPORTED:如果没有，就以非事务方式执行；如果有，就将当前事务挂起。即无论如何不支持事务

6）NEVER：如果没有，就以非事务方式执行；如果有，就抛异常。

7）MANDARORY：如果没有，就抛异常；如果有，就使用当前事务。

16.动态代理

开发步骤：

1.创建原始对象（目标对象）

2. 额外功能：实现MethodBeforeAdvice接口

3.定义切入点

切入点：额外功能加入的位置

目的：有程序员根据自己需要，决定额外功能加入给哪个原始方法

4.组装（2 3整合）

表达含义：所有方法都加permissonCheckProxy的额外功能
 <aop:advisor advice-ref="permissionCheckProxy" pointcut-ref="pc"/>

Xiong2219376948

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Spring的核心API

1.applicationContext 作用：Spring提供的ApplicationContext这个工厂，用于对象的创建。好处：解耦合。接口类型：非web环境下：ClassPathXmlApplicationContext web环境下：XmlWebApplicationContext2.重量级资源①ApplicationContext工厂的对象占用大量内存。②不会频繁的创建对象：一个应用只会创建一个对象。③ApplicationC...
复制链接

扫一扫