Spring 学习 day1 : spring初识,环境,IOC的XML方式使用,IOC的自动装配,IOC的延迟加载

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

别摆烂好吗·

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

阅读量168

点赞数

分类专栏： Spring学习文章标签： spring xml java

本文链接：https://blog.csdn.net/whosedad/article/details/122203401

版权

Spring学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1.Spring初识

Spring 是一个开源框架，Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，由 Rod Johnson在其著作 Expert One-On-One J2EE Development and Design 中阐述的部分理念和原型衍生而来。

它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE应用程序开发提供集成的框架。Spring 使用基本的 JavaBean 来完成以前只可能由 EJB 完成的事情。然而，Spring 的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何 Java 应用都可以从 Spring 中受益。Spring 的核心是控制反转（IOC）和面向切面（AOP）。简单来说，Spring 是一个分层的轻量级开源框架。

2.为什么使用Spring

方便解耦，简化开发
Spring 就是一个大工厂，可以将所有对象创建和依赖关系维护，交给 Spring 管理

AOP 编程的支持，Spring 提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
声明式事务的支持只需要通过配置就可以完成对事务的管理，

而无需手动编程方便程序的测试，Spring 对 Junit4 支持，可以通过注解方便的测试 Spring 程序
方便集成各种优秀框架，Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz 等）的直接支持

降低 JavaEE API 的使用难度，Spring 对 JavaEE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等），都提供了封装，使这些 API 应用难度大大降低

3.环境搭建

3.1 创建java项目导入相应的jar包

3.2 创建配置文件

配置文件的名字可以任意设置,但是建议设置为applicationContext.xml,我们在src目录下创建该文件即可

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
 
</beans>

3.3 添加相应的模块

在项目中添加dao,model,service层的代码

3.4 将bean的实例化交给spring

在该xml文件中,可以通过标签来创建对象,并且给对象的属性赋值

上半部分是通过对象的set方法注入的对象,下半部分是通过构造方法注入的对象

将userDao对象创建出来后,注入到userService这个对象中

对象注入:

       <!--
         id:表示创建的对象名字
         class:表示要创建的对象全类名
         ref:表示要映射的对象名称
      -->
      <bean id="userService" class="com.tledu.service.impl.UserServiceImpl">
            <!--<property name="userDao" ref="userDao"></property>-->
            <!--
               构造器赋值
            -->
            <constructor-arg index="0" ref="userDao"></constructor-arg>
            <constructor-arg index="1" ref="userDao"></constructor-arg>
      </bean>

普通属性注入:

<bean name="userDao" class="com.tledu.dao.impl.UserDaoImpl">
<!-- 如果不是指向对象,直接用value设置值就行 -->
	<property name="daoId" value="82"></property>
	<property name="daoStatus" value="good"></property>
</bean>

集合属性注入:

<bean name="userDao" class="com.tledu.dao.impl.UserDaoImpl">
  <property name="lists" >
  	<list>
    	<value>1</value>
    	<value>2</value>
  	</list>
  </property>
  <property name="sets" >
  <!-- set不可重复,重复不添加,所以只有第一个三 -->
  	<set>
    	<value>3</value>
    	<value>3</value>
    	<value>5</value>
    	<value>4</value>
  	</set>
  </property>
  <property name="maps">
  <!-- mapkey不可重复,重复key不添加,value覆盖 -->
  	<map>
    	<entry key="1"  value="2"></entry>
    	<entry key="1"  value="3"></entry>
    	<entry key="2"  value="2"></entry>
  	</map>
  </property>
	</bean>

	<bean id="userService" class="com.tledu.zrz.service.UserService"
  scope="singleton">
  <!-- 构造方法注入 -->
  <constructor-arg>
  	<ref bean="userDao" />
  </constructor-arg>
	</bean>

3.5 容器(scope)

容器就相当于applicationContext.xml这个文件

spring中scope是一个非常关键的概念，简单说就是对象在spring容器（IOC容器）中的生命周期，也可以理解为对象在spring容器中的创建方式。

目前，scope的取值有5种取值：

在Spring 2.0之前，有singleton和prototype两种；

在Spring 2.0之后，为支持web应用的ApplicationContext，增强另外三种：request，session和global session类型，它们只实用于web程序，通常是和XmlWebApplicationContext共同使用

3.5.1 singleton

此取值表明容器中创建时只存在一个实例,所有的引用此bean都是单一实例,也就是说创建对象时单例模式,并且如果不进行设置,默认就是单例模式.

3.5.2 prototype

spring容器在进行输出prototype的bean对象时，会每次都重新生成一个新的对象给请求方，虽然这种类型的对象的实例化以及属性设置等工作都是由容器负责的，但是只要准备完毕，并且对象实例返回给请求方之后，容器就不在拥有当前对象的引用，请求方需要自己负责当前对象后继生命周期的管理工作，包括该对象的销毁(如果是单例模式的情况,那么创建出来的对象会随着xml文件的生成而创建,伴随着xml文件的销毁而销毁,但是prototype模式下创建的对象不是这样,当xml文件运行时创建,而当xml文件销毁时这个对象并不会被销毁)。也就是说，容器每次返回请求方该对象的一个新的实例之后，就由这个对象“自生自灭”，最典型的体现就是spring与struts2进行整合时，要把action的scope改为 prototype。

简单来说,就是每次获取都创建一个新对象,并且这个对象的生命周期不归Spring管理

3..5.3 request

request，session和global session类型只适用于web程序，通常是和XmlWebApplicationContext共同使用。

Spring容器，即XmlWebApplicationContext 会为每个HTTP请求创建一个全新的RequestPrecessor对象，当请求结束后，该对象的生命周期即告结束，如同java web中request的生命周期。当同时有100个HTTP请求进来的时候，容器会分别针对这10个请求创建10个全新的RequestPrecessor实例，且他们相互之间互不干扰，简单来讲，request可以看做prototype的一种特例，除了场景更加具体之外，语意上差不多。

<bean id ="requestPrecessor" class="...RequestPrecessor" scope="request" />

3.5.4 session

对于web应用来说，放到session中最普遍的就是用户的登录信息，对于这种放到session中的信息，我们可以使用如下形式的制定scope为session：

<bean id ="userPreferences" class="...UserPreferences" scope="session" />

Spring容器会为每个独立的session创建属于自己的全新的UserPreferences实例，比request scope的bean会存活更长的时间，其他的方面没区别，如同java web中session的生命周期。

3.5.5 global session

<bean id ="userPreferences" class="...UserPreferences" scope="globalsession" />

global session只有应用在基于porlet的web应用程序中才有意义，它映射到porlet的global范围的session，如果普通的servlet的web 应用中使用了这个scope，容器会把它作为普通的session的scope对待

3.5.6 配置scope方式

<bean name="userDao" class="com.tledu.dao.impl.UserDaoImpl">
  <!-- 如果不是指向对象,直接用value设置值就行 -->
  <property name="daoId" value="82"></property>
  <property name="daoStatus" value="good"></property>
	</bean >
	<!-- scope 
               singleton : 单例 只创建一个,默认就是 
		   prototype : 每一次getBean 都会创建一个新的实例化对象  
               request,session : 需要特殊环境支持 -->
	<bean id="userService" class="com.tledu.service.UserService"
  scope="singleton">
  <!-- 构造方法注入 -->
  <constructor-arg>
  	<ref bean="userDao" />
  </constructor-arg>
</bean>

4.自动装配(自动注入)

上面我们进行对象注入的时候有两种方式

1 set方法注入

2 构造方法注入

现在我们来学习自动注入,就是不需要指定以上两种方式

Autowire : 自动装配,两种取值

1 byName

2 byType

4.1 byName

byName是根据setter方法名字进行匹配,如果找不到,就不赋值

如 setUserDao 方法就会找userDao,如果 bean的ID为 UserDao 也一样找不到,区分大小写

设置方式

<bean name="userDao" class="com.tledu.zrz.dao.impl.UserDaoImpl">
</bean>
<bean id="userService" class="com.tledu.zrz.service.UserService"  
 autowire="byName">
</bean>

4.2 byType

byType是根据setter方法的参数列表中的数据类型进行匹配,如果beans.xml中出现了多个相同类型的对象,就会报错

如 setUserDao(UserDao userDao) 方法就会找UserDao,如果是接口,就找对应的实现类对象

设置方式

<bean name="userDao" class="com.tledu.zrz.dao.impl.UserDaoImpl">
</bean>
<bean id="userService" class="com.tledu.zrz.service.UserService"  
 autowire="byType">
</bean>

4.3 constructor

可以根据构造函数进行依赖的注入

<bean name="userService" class="com.tledu.service.impl.UserServiceImpl" >
    <!--<property name="userDao" ref="userDao" />-->
   <!-- <constructor-arg name="userDao" ref="userDao" />-->
    <constructor-arg>
        <ref bean="userDaooo"></ref>
    </constructor-arg>
</bean>

5.生命周期和迟加载

之前servlet的生命周期

构造方法 -- init -- service -- destroy

那么spring创建对象的生命周期呢?

Spring中是没有init、service和destroy的,但是我们可以指定某个方法在创建完对象之后执行,某个方法在最后销毁的时候执行.

5.1 生命周期

5.1.1 相关类

public void init(){
  System.out.println("init--------");
	}
	public void destroy(){
  System.out.println("destroy----------");
	}
	public UserService() {
  System.out.println("service构造方法");
}

5.1.2 配置文件

<bean name="userDao" class="com.tledu.dao.impl.UserDaoImpl" >
	</bean>
	<!--  
  init-method : 用于设置初始化的方法,可以是任何对应类中的方法
  destory-method : 用于设置销毁资源的方法,可以是任何对应类中的方法
  -->
	<bean id="userService" class="com.tledu.service.UserService"  
  autowire="byName"   init-method="init" destroy-method="destroy"  >
	</bean>

5.2 迟加载

Spring容器默认是在执行

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");

进行解析的时候创建对象并调用init,

如果我们不想让某个类在解析的时候就创建对象,而是用到的时候在创建对象的话,就需要设置迟加载比如想要对userService迟加载可以这样设置

lazy-init="true"

5.2.1 相关类

public UserDaoImpl(){
  System.out.println("Dao构造方法");
}
public UserService() {
  System.out.println("service构造方法");
}

5.2.2 配置文件

<bean name="userDao" class="com.tledu.dao.impl.UserDaoImpl" >
<bean id="userService" class="com.tledu.service.UserService"  scope="prototype"
  	autowire="byName"   init-method="init" destroy-method="destroy" lazy-init="true"  >
</bean>

别摆烂好吗·

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring 学习 day1 : spring初识,环境,IOC的XML方式使用,IOC的自动装配,IOC的延迟加载

1.Spring初识Spring 是一个开源框架，Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，由 Rod Johnson在其著作 Expert One-On-One J2EE Development and Design 中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE应用程序开发提供集成的框架。Spring 使用基本的 JavaBean 来完成以前只可能
复制链接

扫一扫

专栏目录