<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>Live in code &#187; ioc</title>
	<atom:link href="http://www.agatezone.cn/code/tag/ioc/feed" rel="self" type="application/rss+xml" />
	<link>http://www.agatezone.cn/code</link>
	<description>agate&#039;s tech blog</description>
	<lastBuildDate>Tue, 20 Jul 2010 05:35:32 +0000</lastBuildDate>
	<generator>http://wordpress.org/?v=2.9.2</generator>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
			<item>
		<title>Struts2古怪的IOC</title>
		<link>http://www.agatezone.cn/code/archives/44</link>
		<comments>http://www.agatezone.cn/code/archives/44#comments</comments>
		<pubDate>Tue, 01 Apr 2008 11:44:44 +0000</pubDate>
		<dc:creator>agate</dc:creator>
				<category><![CDATA[历程]]></category>
		<category><![CDATA[程序编码]]></category>
		<category><![CDATA[framework]]></category>
		<category><![CDATA[ioc]]></category>
		<category><![CDATA[java]]></category>
		<category><![CDATA[opensource]]></category>
		<category><![CDATA[struts2]]></category>
		<category><![CDATA[webwork]]></category>

		<guid isPermaLink="false">http://www.agatezone.cn/code/?p=44</guid>
		<description><![CDATA[IOC(DI)即依赖注入，参见的就是Spring的IOC容器，实现就是实现符合java bean的规范的带有无参构造函数的带有对应set和get方法的一个java类(pojo)。前面都是废话，我们都知道注入一般就是使用set方法，对需要的成员变量进行动态的赋值指向。一般get没有什么用，所以我们用spring管理的时候一般只需写入需要注入对象的set方法即可。
但是今天开发展现层的时候……我用struts的表单自动注入的特性写了一个CRUD模块，当然我还是使用原先的逻辑：只写set方法。结果值没有正确被赋值(有的时候只有部分值被获取)。而且发现如果是简单的数值类型的参数在只设置set方法的情况下是可以被赋值的，但是要是参数是一个ValueObject这样的一个实体对象：

public class User {
	private String userName;
	private String userPwd;
	// --------other private property
	// --------setter
	// --------getter
}

那么，如果我们在action中只对user属性写了set方法

public class UserAction {
	private User user;
	// --------setter
	public String execute() {
		// --------code...
	}
}

那么经过我不下10次的不同试验，保证是无法正确赋值的！因为……还缺了个get方法。也不知道具体原因是什么(猜想在struts2的IOC中，对于复杂对象的注入可能同时用到了set和get方法)，但是经验告诉的是set和get方法最好都写！
]]></description>
			<content:encoded><![CDATA[<p>IOC(DI)即依赖注入，参见的就是Spring的IOC容器，实现就是实现符合java bean的规范的带有无参构造函数的带有对应set和get方法的一个java类(pojo)。前面都是废话，我们都知道注入一般就是使用set方法，对需要的成员变量进行动态的赋值指向。一般get没有什么用，所以我们用spring管理的时候一般只需写入需要注入对象的set方法即可。</p>
<p>但是今天开发展现层的时候……我用struts的表单自动注入的特性写了一个CRUD模块，当然我还是使用原先的逻辑：只写set方法。结果值没有正确被赋值(有的时候只有部分值被获取)。而且发现如果是简单的数值类型的参数在只设置set方法的情况下是可以被赋值的，但是要是参数是一个ValueObject这样的一个实体对象：</p>
<pre class="brush: java;">
public class User {
	private String userName;
	private String userPwd;
	// --------other private property
	// --------setter
	// --------getter
}
</pre>
<p>那么，如果我们在action中只对user属性写了set方法</p>
<pre class="brush: java;">
public class UserAction {
	private User user;
	// --------setter
	public String execute() {
		// --------code...
	}
}
</pre>
<p>那么经过我不下10次的不同试验，保证是无法正确赋值的！因为……还缺了个get方法。也不知道具体原因是什么(猜想在struts2的IOC中，对于复杂对象的注入可能同时用到了set和get方法)，但是经验告诉的是set和get方法最好都写！</p>
]]></content:encoded>
			<wfw:commentRss>http://www.agatezone.cn/code/archives/44/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>spring ioc 快速入门</title>
		<link>http://www.agatezone.cn/code/archives/24</link>
		<comments>http://www.agatezone.cn/code/archives/24#comments</comments>
		<pubDate>Thu, 06 Dec 2007 13:45:07 +0000</pubDate>
		<dc:creator>agate</dc:creator>
				<category><![CDATA[程序编码]]></category>
		<category><![CDATA[ioc]]></category>
		<category><![CDATA[java]]></category>
		<category><![CDATA[spring]]></category>

		<guid isPermaLink="false">http://www.agatezone.cn/?p=24</guid>
		<description><![CDATA[一直以来我们总是使用new的方式来创建对象或对象层级之间的关系
ClassOne one = new ClassOneImpl();
用 UML 图示很明确的告诉我们一个引用只是一个箭头，那我们平时那种new的方式建立关系的方法让我们在以后的代码修改还是添加功能的时候会造成大量的代码修改，比如我们把上面这个 ClassOneImpl 实现更换成新的一个实现 ClassOneImpl2 那么我们就要修改所有代码中 ClassOneImpl 的部分……如果这个工程很大的话，这个可是件可怕的修改工程啊！
IOC，即 Inversion of control 中文意思为"控制反转"，个人理解即为把过去在代码中 new 的方式在编译时绑定关系进而在运行时使用的对象关系方式，转化成在运行时加载的方式，即所谓的"反转"。
现在我用一个十分简单的例子实现IOC的HelloWorld

建立以下一系列java文件：具体请看代码注释！

package cn.agatezone.spring.helloworld;

public class BeanA {
	private String str = &#34;Hello World&#34;;
	public String getStr() {
		return str;
	}
}


package cn.agatezone.spring.helloworld;

public class BeanB {
	private BeanA beanA;
	public void setBeanA(BeanA beanA) {
		this.beanA = beanA;
	}
	public void sayHelloWorld() {
		System.out.println(beanA.getStr());
	}
}

这两个是十分简单的两个类对吧！BeanA.java没什么好说的，我们看看那个BeanB.java，不知道你有没有发现我们这里的成员变量beanA没有实例化过……也许你会问：难道这样在sayHelloWorld()方法中使用beanA.getStr()不会出错？呵呵，当然，在我们传统的编码方式下这个代码是会出错的！因为beanA为null嘛！但是我们这里介绍的spring的ioc可以将过去传统的那种new方式获得对象引用的方式利用"依赖注入"（DI）的方式在运行时把BeanA的实例加载到BeanB的实例对象中去！
这里我们介绍一下 DI-Dependency Injection 即"依赖注入"，只是一种形象的说法，意图与IOC如出一辙，就是在运行时期，动态地将实例化的对象加入到要使用这些对象的对象中去。呵呵很拗口对吧，就比如我们这里的BeanA.java中的beanA这个引用，咋一看没有实例化，但是我们可以利用spring的ioc容器在运行时给他加入一个实例化，避免我们new咯！这个就是注入！
要使用spring的ioc托管当然我们要告诉spring如何管理他们咯，如何管理呢？聪明的你一定会晓得是用xml配置文件啦！
那么请看下面这段配置文件代码：

&#60;?xml version=&#34;1.0&#34; encoding=&#34;UTF-8&#34;?&#62;
&#60;!DOCTYPE beans PUBLIC &#34;-//SPRING//DTD [...]]]></description>
			<content:encoded><![CDATA[<p>一直以来我们总是使用new的方式来创建对象或对象层级之间的关系<br />
<code>ClassOne one = new <span style="color: #ff0080">ClassOneImpl</span>();</code><br />
用 UML 图示很明确的告诉我们一个引用只是一个箭头，那我们平时那种new的方式建立关系的方法让我们在以后的代码修改还是添加功能的时候会造成大量的代码修改，比如我们把上面这个 <span style="color: #ff00ff">ClassOneImpl</span> 实现更换成新的一个实现 <span style="color: #00ff00">ClassOneImpl2</span> 那么我们就要修改所有代码中 <span style="color: #ff00ff">ClassOneImpl</span> 的部分……如果这个工程很大的话，这个可是件可怕的修改工程啊！</p>
<p>IOC，即 Inversion of control 中文意思为"控制反转"，个人理解即为把过去在代码中 new 的方式在编译时绑定关系进而在运行时使用的对象关系方式，转化成在运行时加载的方式，即所谓的"反转"。</p>
<p>现在我用一个十分简单的例子实现IOC的HelloWorld<br />
<span id="more-24"></span><br />
建立以下一系列java文件：具体请看代码注释！</p>
<pre class="brush: java;">
package cn.agatezone.spring.helloworld;

public class BeanA {
	private String str = &quot;Hello World&quot;;
	public String getStr() {
		return str;
	}
}
</pre>
<pre class="brush: java;">
package cn.agatezone.spring.helloworld;

public class BeanB {
	private BeanA beanA;
	public void setBeanA(BeanA beanA) {
		this.beanA = beanA;
	}
	public void sayHelloWorld() {
		System.out.println(beanA.getStr());
	}
}
</pre>
<p>这两个是十分简单的两个类对吧！BeanA.java没什么好说的，我们看看那个BeanB.java，不知道你有没有发现我们这里的成员变量beanA没有实例化过……也许你会问：难道这样在sayHelloWorld()方法中使用beanA.getStr()不会出错？呵呵，当然，在我们传统的编码方式下这个代码是会出错的！因为beanA为null嘛！但是我们这里介绍的spring的ioc可以将过去传统的那种new方式获得对象引用的方式利用"依赖注入"（DI）的方式在运行时把BeanA的实例加载到BeanB的实例对象中去！</p>
<blockquote><p>这里我们介绍一下 <span style="color: #0000ff">DI-Dependency Injection</span> 即"依赖注入"，只是一种形象的说法，意图与IOC如出一辙，就是在运行时期，动态地将实例化的对象加入到要使用这些对象的对象中去。呵呵很拗口对吧，就比如我们这里的BeanA.java中的beanA这个引用，咋一看没有实例化，但是我们可以利用spring的ioc容器在运行时给他加入一个实例化，避免我们new咯！这个就是注入！</p></blockquote>
<p>要使用spring的ioc托管当然我们要告诉spring如何管理他们咯，如何管理呢？聪明的你一定会晓得是用xml配置文件啦！</p>
<p>那么请看下面这段配置文件代码：</p>
<pre class="brush: xml;">
&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;
&lt;!DOCTYPE beans PUBLIC &quot;-//SPRING//DTD BEAN//EN&quot;
&quot;http://www.springframework.org/dtd/spring-beans.dtd&quot;&gt;
&lt;beans&gt;
	&lt;!-- 这里是我们需要配置的地方,其他的是固定格式! --&gt;
	&lt;!-- 在spring的世界里,多有的java对象都成为bean --&gt;
	&lt;!--
		声明beanA的实例
		给定id(就是实例的名称)
		给定class(就是对应实例的完整类路径)
	--&gt;
	&lt;bean id=&quot;beanA&quot; class=&quot;cn.agatezone.spring.helloworld.BeanA&quot;&gt;
	&lt;/bean&gt;
	&lt;!-- 声明beanB的实例 --&gt;
	&lt;bean id=&quot;beanB&quot; class=&quot;cn.agatezone.spring.helloworld.BeanB&quot;&gt;
	&lt;!--
		我们的BeanB.java中有一个BeanA的成员变量叫做beanA
		我们把前面的那个声明的bean:beanA在此注入到beanB这个实例中去
	--&gt;
		&lt;property name=&quot;beanA&quot; ref=&quot;beanA&quot;&gt;
		&lt;/property&gt;
	&lt;/bean&gt;
&lt;/beans&gt;
</pre>
<p>我们有了这些以后就可以实现一个简单的ioc的helloworld应用了！</p>
<p>请看我们的测试代码：</p>
<pre class="brush: java;">
package cn.agatezone.spring.helloworld;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloWorld {
	public static void main(String[] args) {
		//声明一个string来给出配置文件相对类的路径
		String path = &quot;cn/agatezone/spring/helloworld/applicationContext.xml&quot;;
		/*
		 * ApplicationContext为spring的一个主要上下文工厂
		 * 其功能很多，我们这里只用其来拿出bean(就是我们的实例)
		 * 因为它是借口，这里我们用对应类路径的ClassPathXmlApplicationContext来实例化他
		 */
		ApplicationContext act = new ClassPathXmlApplicationContext(path);
		//简单吧!像工厂一样使用，获得BeanB的实例
		BeanB bean = (BeanB)act.getBean(&quot;beanB&quot;);
		//注意哦!这时候我们强大的spring容器已经将beanA注入到beanB这中了!
		bean.sayHelloWorld();
	}
}
</pre>
<p>结果在你运行之后应该不难想象吧！控制台输出HelloWorld，说明即使我们不在类中显式地声明对象实例，依靠我们的spring-ioc容器一样可以在运行时将对象注入！这样对我们未来的代码维护以及功能扩展都有很深远的意义！</p>
]]></content:encoded>
			<wfw:commentRss>http://www.agatezone.cn/code/archives/24/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
	</channel>
</rss>
