在J2EE开发平台中,Spring是一种优秀的轻量级企业应用解决方案。Spring倡导一切从实际出发,它的核心技术就是IOC(控制反转)和AOP(面向切面编程)技术。本文用的Spring版本为spring-framework-2.5.6(通过Myeclipse导入),不同版本的jar包可能会存在不同的区别。

Spring内置了日志组件log4j.jar,所以在正式使用Spring之前需要对log4j进行简单的配置,在项目的src根目录下创建log4j.properties属性文件。具体代码如下:

#输出级别,输出错误信息,输出源为标准输出源stdout
log4j.rootLogger=WARN,stdout
#将stdout输出到控制台中
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
#日志输出的布局类
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
#指定日志输出内容的格式
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] -%m %n

依赖注入

IoC,即控制反转。开发者在使用类的实例之前,需要先创建对象的实例。但是IoC将创建实例的任务交给IoC容器,这样开发应用代码时只需要直接使用类的实例,这就是IoC。在讨论控制反转这个概念的过程中,Martin Fowler提出了一个更为准确的概念,叫做依赖注入(Dependency Injection)。

1. Setter注入

例1.1 通过Spring的赋值为用户JavaBean的属性赋值。

(1)首先创建用户的JavaBean,关键代码如下:

package com.cn.gao;

public class User {
private String name;
private Integer age;
private String sex;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}

(2)在Spring的配置文件applicationContext.xml中配置该JavaBean。关键代码如下:

<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<!-- User Bean -->
<bean name="user" class="com.cn.gao.User">
<property name="name">
<value>小强</value>
</property>
<property name="age">
<value>26</value>
</property>
<property name="sex">
<value>男</value>
</property>
</bean> </beans>

说明:如果当JavaBean的某个属性是List集合类型或数组时,需要使用<list>标签为List集合类型或数组的每一个元素赋值。

(3)创建类Manger,在其main()方法中的关键代码如下:

package com.cn.gao;

import org.springframework.core.io.Resource;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource; public class Manger {
public static void main(String[] args) {
Resource resource =new ClassPathResource("applicationContext.xml"); //装载配置文件
BeanFactory factory = new XmlBeanFactory(resource);
User user = (User)factory.getBean("user"); //获取bean
System.out.println("用户姓名————"+user.getName());
System.out.println("用户年龄————"+user.getAge());
System.out.println("用户性别————"+user.getSex());
}
}

程序运行后,在控制台输出的信息如下图所示:

2. 构造器注入

在类被实例化时,它的构造方法被调用并且只能调用一次。所以构造器常被用于类的初始化操作。<constructor-arg>是<bean>元素的子元素。通过<constructor-arg>元素的<value>子元素可以为构造方法传参。

例2.1 通过Spring的构造器注入为用户JavaBean的属性赋值。

(1)在用户JavaBean中创建构造方法,关键代码如下:

package com.cn.gao;

public class User {
private String name;
private Integer age;
private String sex;
//构造方法
public User(String name,Integer age,String sex){
this.name=name;
this.age=age;
this.sex=sex;
}
//输出JavaBean的属性值方法
public void printInfo(){
System.out.println("用户姓名——"+name);
System.out.println("用户年龄——"+age);
System.out.println("用户性别——"+sex);
}
}

(2)在Spring的配置文件applicationContext.xml中通过<constructor-arg>元素为JavaBean的属性赋值。

<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<!-- User Bean -->
<!--
<bean name="user" class="com.cn.gao.User">
<property name="name">
<value>小强</value>
</property>
<property name="age">
<value>26</value>
</property>
<property name="sex">
<value>男</value>
</property>
</bean>
--> <!-- User Bean -->
<bean name="user" class="com.cn.gao.User">
<constructor-arg>
<value>小强</value>
</constructor-arg>
<constructor-arg>
<value>26</value>
</constructor-arg>
<constructor-arg>
<value>男</value>
</constructor-arg>
</bean>
</beans>

注意:容器中通过多个<constructor-arg>标签完成了对构造方法的传参,但是如果标签的赋值顺序与构造方法中参数的顺序或参数类型不同,程序会产生异常。可以使用

<constructor-arg>元素的index属性和type属性解决此类问题。

说明:(1)index属性:用于指定构造方法的参数索引,指定当前<constructor-arg>标签为构造方法的哪个参数赋值。

   (2)type属性:可以指定参数类型以确定要为构造方法的哪个参数赋值,当需要赋值的属性在构造方法中没有相同的类型时,可以使用这个参数。

(3)创建类Manger,在其main()方法中的关键代码如下:

package com.cn.gao;

import org.springframework.core.io.Resource;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource; public class Manger {
public static void main(String[] args) {
Resource resource =new ClassPathResource("applicationContext.xml"); //装载配置文件
BeanFactory factory = new XmlBeanFactory(resource);
User user = (User)factory.getBean("user"); //获取bean
// System.out.println("用户姓名————"+user.getName());
// System.out.println("用户年龄————"+user.getAge());
// System.out.println("用户性别————"+user.getSex());
user.printInfo(); //输出JavaBean的属性值
}
}

程序运行后,在控制台输出的信息如下图所示:

3. 引用其他的bean

Spring利用IoC将JavaBean所需要的属性注入到其中,不需要编写程序代码来初始化JavaBean的属性,使程序代码整洁、规范化。最主要的是它降低了JavaBean之间的耦合度,Spring开发项目中的JavaBean不需要任何修改就可以应用到其它程序中。在Spring中可以通过配置文件使用<ref>元素引用其他JavaBean的实例对象。

例3.1 将User对象注入到Spring的控制器Manger1中,并在控制器中执行User的printInfo()方法。

(1)在控制器Manger1中注入User对象,关键代码如下:

package com.cn.gao;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController; public class Manger1 extends AbstractController {
private User user; //注入User对象
public User getUser(){
return user;
} public void setUser(User user){
this.user=user;
}
@Override
protected ModelAndView handleRequestInternal(HttpServletRequest arg0,
HttpServletResponse arg1) throws Exception {
user.printInfo(); //执行User中的信息打印方法
return null;
} }

说明:如果在控制器中返回的是一个ModelAndView对象,那么该对象需要在Spring的配置文件applicationContext.xml中进行配置。

(2)在Spring的配置文件applicationContext.xml中设置JavaBean的注入,关键代码如下:

    <!-- 注入JavaBean -->
<bean name="/main.do" class="com.cn.gao.Manger1">
<property name="user">
<ref bean="user"/>
</property>
</bean>

(3)在web.xml文件中配置自动加载applicationContext.xml文件,在项目启动时,Spring的配置信息将自动加载到程序中,所以在调用JavaBean时不再需要实例化BeanFactory对象。

<?xml version="1.0" encoding="GBK"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
<display-name>java_spring</display-name>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param> <!-- 设置自动加载配置文件 -->
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>

Spring3系列5-Bean的基本用法

Spring核心之IoC——依赖注入的更多相关文章

  1. Spring学习-spring核心机制-IOC依赖注入

    转载自:http://www.cnblogs.com/chenssy/archive/2012/11/11/2765266.html 今天复习一下spring两大特性之一:IOC依赖注入,看了一下大佬 ...

  2. Spring进阶之路(1)-Spring核心机制:依赖注入/控制反转

    原文地址:http://blog.csdn.net/wangyang1354/article/details/50757098 我们经常会遇到这样一种情景,就是在我们开发项目的时候经常会在一个类中调用 ...

  3. (转)Spring读书笔记-----Spring核心机制:依赖注入

    Java应用(从applets的小范围到全套n层服务端企业应用)是一种典型的依赖型应用,它就是由一些互相适当地协作的对象构成的.因此,我们说这些对象间存在依赖关系.加入A组件调用了B组件的方法,我们就 ...

  4. Spring核心机制:依赖注入

    转载:http://www.cnblogs.com/chenssy/ Java应用(从applets的小范围到全套n层服务端企业应用)是一种典型的依赖型应用,它就是由一些互相适当地协作的对象构成的.因 ...

  5. Spring读书笔记-----Spring核心机制:依赖注入

    spring框架为我们提供了三种注入方式,分别是set注入,构造方法注入,接口注入.今天就和大家一起来学习一下 依赖注入的基本概念 依赖注入(Dependecy Injection),也称为IoC(I ...

  6. Spring.NET 的IOC(依赖注入)

    (1)  ioc,意思是Inversion of control,(反转控制),控制反转,就是交换控制权的意思.现在一般不使用这个词,一般使用dependency injection(依赖注入).依赖 ...

  7. Spring核心——Bean的依赖注入

    依赖注入在设计模式与IoC这篇文章中,介绍了Spring基础的三大支柱的两项内容——IoC.Bean.本篇将继续围绕着Bean的创建时的注入方式来介绍Spring的核心思想与设计模式. 天底下所有面向 ...

  8. 30个类手写Spring核心原理之依赖注入功能(3)

    本文节选自<Spring 5核心原理> 在之前的源码分析中我们已经了解到,依赖注入(DI)的入口是getBean()方法,前面的IoC手写部分基本流程已通.先在GPApplicationC ...

  9. 7 -- Spring的基本用法 -- 3... Spring 的核心机制 : 依赖注入

    7.3 Spring 的核心机制 : 依赖注入 Spring 框架的核心功能有两个. Spring容器作为超级大工厂,负责创建.管理所有的Java对象,这些Java对象被称为Bean. Spring容 ...

随机推荐

  1. Expert C Programming 阅读笔记(~CH1)

    P4: 好梗!There is one other convention—sometimes we repeat a key point to emphasize it. In addition, w ...

  2. day5模块

    模块,用一砣代码实现了某个功能的代码集合. 类似于函数式编程和面向过程编程,函数式编程则完成一个功能,其他代码用来调用即可,提供了代码的重用性和代码间的耦合.而对于一个复杂的功能来,可能需要多个函数才 ...

  3. python基本数据类型的用法和区别

    原文:http://www.cnblogs.com/soaringEveryday/p/5044007.html Python语言简洁明了,可以用较少的代码实现同样的功能.这其中Python的四个内置 ...

  4. 【51nod】1227 平均最小公倍数

    题解 这个故事告诉们数论函数不要往分式上跑,你推不出来 好久没推式子了这么明显的转化我都忘了= = 首先\(A(n) = \frac{1}{n} \sum_{i = 1}^{n} \frac{i * ...

  5. MySQL几个特别语法示例

    简单介绍MySQL中几种特殊语法的用法: 1.创建示例用表和数据: 创建employees表[注:与SQL Server示例数据库Northwind中的表employees相同的表结构]: CREAT ...

  6. mongoDB学习第二天之常用方法

    mongoDB LIMIT 和 SKIP 方法 db.colName.find().limit(num)  # limit 方法接收一个数字参数,该参数指定读取的记录条数 (db.colName.fi ...

  7. Python的环境搭建——万丈高楼平地起

    Python的环境搭建,远程连接,端口映射,虚拟机 写在正文之前 python语言的开发环境还是相对比较简单的,但是也是有很多需要注意的地方,对于初次接触python或者以前很少用到虚拟环境的朋友来说 ...

  8. Spring框架中ModelAndView、Model、ModelMap区别 (转)

    原文地址:http://www.cnblogs.com/google4y/p/3421017.html SPRING框架中ModelAndView.Model.ModelMap区别   注意:如果方法 ...

  9. Bzoj2038/洛谷P1494 小Z的袜子(莫队)

    题面 Bzoj 洛谷 题解 考虑莫队算法,首先对询问进行分块(分块大小为\(sqrt(n)\)),对于同一个块内的询问,按照左端点为第一关键字,右端点为第二关键字排序.我们统计这个区间内相同的颜色有多 ...

  10. 使用webgl(three.js)创建3D机房,3D机房微模块详细介绍(升级版二)

    序: 上节课已经详细描述了普通机房的实现过程,文章地址(https://www.cnblogs.com/yeyunfei/p/10473021.html) 紧接着上节课的内容 我们这节可来详细讲解机房 ...