Web43Spring笔记一

最新推荐文章于 2025-01-12 20:51:11 发布

原创最新推荐文章于 2025-01-12 20:51:11 发布 · 222 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#spring #IOC

JAVA EE 专栏收录该内容

37 篇文章

订阅专栏

在这里插入图片描述

1基本开发步骤

1.1 导包

首先需要导入的是下面四个最基本的jar包。
在这里插入图片描述
然后导入日志的jar包

实际上日志的jar包可以只导一个，可以不导log4j的，spring4以前开始是需要导入的。

1.2 创建一个对象

public class User {
	private String name;
	private Integer age;
}

1.3 书写配置注册对象到容器

位置任意，建议放到src目录下，名称任意，建议applicationContext.xml。
首先是导入约束，可以从docs\spring-framework-reference\html文件夹下找到xsd-configuration.html文件进行导入。

<?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">
	<!-- 把对象交给spring -->
    <bean id="user" class="com.dlj.entity.User">
    </bean>

</beans>

2 IOC和DI

IOC:Inverse of Control控制反转，指将对象的创建权交给了Spring，DI是IOC实现的必要条件
DI： Dependence Injection依赖注入,.需要有IOC的环境,Spring创建这个类的过程中,Spring将类的依赖的属性设置进去.

注入方式：
- set方法注入
- 构造方法注入
- 字段注入
注入类型
- 值类型注入
- 引用类型注入

IOC参考连接：https://blog.youkuaiyun.com/yasinshaw/article/details/108067951

3 BeanFactory和ApplicaitonContext

在这里插入图片描述
BeanFactory接口是Spring原始接口，针对原始接口的实现类功能较为单一，其特点是每次在获得对象的时候才会创建对象。
**ApplicationContext:**每次容器启动时，就会创建容器中配置的所有对象，并提供了更多的功能。
ClassPathXmlApplicationContext:从类路径下加载配置文件
FileSystemXmlApplicationContent:从硬盘绝对路径下加载配置文件
web开发中，使用applicationContext,在资源匮乏的环境可以使用BeanFactory.

4 Bean元素

4.1 Bean元素属性介绍

Bean元素：使用该元素描述需要Spring管理的对象
		name属性：给被管理的对象起个名字，获得对象时根据该名称获得对象，名称可以重复，可以使用特殊字符
		class属性：被管理对象的完整类名
		id属性：与name属性一样，名称不可重复，不能使用特殊字符
开发时尽量使用name属性

4.2 Bean元素创建方式

空参构造创建方式

 <bean id="user" class="com.dlj.entity.User">
    </bean>
    ApplicationContext ac = new ClassPathXmlApplicationContext("com/dlj/b_create/applicationContext.xml");

在配置文件里，这样写bean元素，然后通过ClassPathXmlApplicationContext方法加载配置文件，就时空参创建方式。

静态工厂创建

 <!-- 创建方式二：通过静态工厂创建 
    	调用UserFactory的createUser方法创建名为user2的对象，放入容器
    -->
    <bean name="user2" class="com.dlj.b_create.UserFactory" factory-method="createUser"></bean>
    public static User createUser() {
		System.out.println("静态工厂创建");
		return new User();
	}

实例工厂创建

<!-- 创建方式三：实例工厂创建 
		调用userFactory对象的createUser2方法创建名为user3的对象，放入容器
	-->
	<bean name="user3" factory-bean="userFactory" factory-method="createUser2"></bean>
	<bean name="userFactory" class="com.dlj.b_create.UserFactory"></bean>
public User createUser2() {
		System.out.println("实例工厂创建");
		return new User();
	}

4.3 scope属性：Bean的作用范围

sdsinglton:默认值单例,即在容器中只创建一个实例
prototype :多例，每次请求获得对象的时候都会创建一个新的对象
request :web环境下对象与request生命周期一致，将对象放到request域中
session :web环境下对象与request生命周期一致，将对象放到session域中

PS：在整合struts2时，ActionBean必须配置为多例的

4.4 生命周期属性

配置一个方法作为生命周期初始化方法，spring会在对象创建之后立即调用 init-method
配置一个方法作为生命周期的销毁方法，spring容器在关闭并销毁苏哦有容器中的对象之前调用 destory-method

5 其它配置

5.1 导入其他配置文件

<import resource="com/dlj/b_create/applicationContext.xml"></import>

5.2 Spring属性注入

set方法注入

	<!-- set方法注入 -->
    <bean id="user" class="com.dlj.entity.User">
    	<!-- 为User对象中的name属性注入tom作为值 -->
    	<property name="name" value="tom"></property>
    	<property name="age" value="18"></property>
    	<!-- 为car属性注入下方配置的car对象 -->
    	<property name="car" ref="car"></property>
    </bean>
    <!-- 将car对象配置到容器中 -->
    <bean name="car" class="com.dlj.entity.Car">
    	<property name="name" value="兰博基尼"></property>
    	<property name="color" value="黄色"></property>
    </bean>

set方法注入分为两种，第一种是基本类型的注入，直接用name和value标记就可以，对于引用类型的注入，首先我们需要把那个要注入的对象给配置到文件中，然后，再使用ref属性进行注入，这里具体是指先配置car对象，然后再在user对象中进行引用。

构造函数注入

<bean name="user1" class="com.dlj.entity.User">
    	<constructor-arg name="name" value="jerry" index="0" type="java.lang.Integer"></constructor-arg>
    	<constructor-arg name="car" ref="car"></constructor-arg>
    </bean>

这里注意参数是constructor-arg ,另外index属性是用来设置参数的顺序的，比如说，一个类里面有两个构造参数，里面的参数是一样的，但顺序不一样，这个时候就可以通过index属性来指定参数的顺序。type属性是用来指你要加载的参数的类型。

p名称空间注入

//首先需要导入约束：
xmlns:p="http://www.springframework.org/schema/p"
 <bean name="user2" class="com.dlj.entity.User" p:name="jack" p:age="20"  p:car-ref="car"></bean>

//然后注意基本类型 p:name和引用类型p:car-ref。

普通属性: p:属性名称=””
- 对象类型属性: p:属性名称-ref=””

SpEL注入
spring expression language

<bean name="user3" class="com.dlj.entity.User" >
	<property name="name" value="#{user2.name}"></property>
		<property name="age" value="18"></property>
    	<!-- 为car属性注入下方配置的car对象 -->
    	<property name="car" ref="car"></property>
	</bean>

语法：#{SpEL}，这里的一个应用场景是在一个bean中获取其他bean的值

5.3 复杂类型注入

<!-- 复杂类型注入 -->
<!-- array注入 -->
<bean name="cb" class="com.dlj.c_injection.CollectionBean">
<!-- 如果数组中只准备注入一个值(对象)，直接使用value|ref即可 -->
<!-- <property name="arr" value="1"></property> -->
	<property name="arr" >
		<array>
		   <value>"tom"</value>
		   <value>"jerry"</value>
		   <ref bean="user3"></ref>
		</array>
	</property>
	
	<!-- 如果list中只准备注入一个值(对象)，直接使用value|ref即可 -->
<!-- <property name="list" value="1"></property> -->
<property name="list" >
	<list>
	 <value>"toms"</value>
		   <value>"jerrys"</value>
		   <value>"jerryss"</value>
		   <ref bean="user3"></ref>
	</list>
</property>
	<!-- map类型注入 -->
	<property name="map">
		<map>
			<entry key="url" value="www.baidu.com"></entry>
			<entry key="car" value-ref="car"></entry>
			<entry key-ref="user2" value-ref="car"> </entry>
		</map>
	</property>
<!-- properties类型注入 -->
<property name="prop">
	<props>
		<prop key="driverclass">wgagagla</prop>
	</props>
</property>
</bean>

6 管理spring容器在项目中的生命周期

ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
		// 2.获得CustomerService对象
		CustomerService cs = (CustomerService) ac.getBean("customerService");

上面的这种方式并不对，一个项目里应该只有一个容器，如果上面的代码写在了Action中的每一个方法里，它就会每次都重新创建一个容器，正确的方式是在web.xml文件中通过监听器配置，如下：

 <!-- 可以让spring容器随项目的启动而创建，随项目的关闭而销毁 -->
  <listener>
  	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- 指定加载spring配置文件的位置 -->
  <context-param>
  	<param-name>contextConfigLocation</param-name>
  	<param-value>classpath:applicationContext.xml</param-value>
  </context-param>

从servletContext中获得spring容器

// 1获得ServletContext对象
		ServletContext sc = ServletActionContext.getServletContext();
		/// 1.从ServletContext中获得容器
		WebApplicationContext ac = WebApplicationContextUtils.getWebApplicationContext(sc);
		CustomerService ser = (CustomerService) ac.getBean("customerService");