Spring使用之IOC配置篇

最新推荐文章于 2024-04-24 22:52:03 发布

beyond0851

最新推荐文章于 2024-04-24 22:52:03 发布

阅读量99

点赞数

分类专栏： Spring 文章标签： java 运维

Spring 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本计划分为四篇概括Spring常用的知识：IOC配置篇、AOP配置篇、IOC注解篇、AOP注解篇。

Spring核心分为IOC和AOP，这两点在我的工作中经常使用，DI又是IOC的核心实现，理论不多说，程序只有测试通过才能是真正的理解入门，其他一切空谈。

下面是接口：

package spring.config.iInterface;

public interface IUserDAO {
public void save();
public void delete();
}

下面是Action类：

package spring.config.service;

import spring.config.iInterface.IUserDAO;

public class UserAction {
private IUserDAO userDao;//接口类型

public String register(){
System.out.println("register()方法被调用...");
userDao.save();
userDao.delete();
return "success";
}

//setter方式注入,自动调用
public void setUserDao(IUserDAO userDao){
System.out.println("--setUserDao(UserDAO userDao)被调用...--");
this.userDao = userDao;
}

public IUserDAO getUserDao() {
return userDao;
}
}

package spring.config.service;

import spring.config.iInterface.IUserDAO;

public class UserAction1 {
private IUserDAO userDao;
//构造方法注入,自动调用
public UserAction1() {
System.out.println("---constructs----default--");
}

public UserAction1(IUserDAO userDao,int a){
System.out.println("---constructs--1--a:"+a);
this.userDao = userDao;
}

public UserAction1(IUserDAO userDao){
System.out.println("---constructs----2--");
this.userDao = userDao;
}

public String register(){
userDao.save();
userDao.delete();
return "success";
}
}

下面是bean类

package spring.config.bean;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class MessageBean {
private String username;
private String password;
private int size;
private List<String> citys;
private Set<String> friends;
private Map<Integer,String> books;
private Properties props;

public void show(){
System.out.println("用户名:"+username);
System.out.println("密码:"+password);
System.out.println("允许连接数:"+size);
System.out.println("-----城市列表-----");
for(String str:citys){
System.out.println(str);
}
System.out.println("-----朋友列表-----");
for(String str:friends){
System.out.println(str);
}
System.out.println("------图书列表------");
Set<Integer> keys = books.keySet();
for(Integer key:keys){
System.out.println(key+" "+books.get(key));
}
System.out.println("------系统参数信息-----");
Set<?> params = props.keySet();
for(Object obj:params ){
System.out.println(obj+" : "
+props.getProperty(obj.toString()));
}
}

public void setCitys(List<String> citys) {
this.citys = citys;
}

public void setBooks(Map<Integer, String> books) {
this.books = books;
}

public void setProps(Properties props) {
this.props = props;
}

public void setFriends(Set<String> friends) {
this.friends = friends;
}

public void setSize(int size) {
this.size = size;
}

public void setPassword(String password) {
this.password = password;
}

public void setUsername(String username) {
this.username = username;
}
}

下面是配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">

<beans>
<bean id="userdao" class="spring.config.impl.HibernateUserDAO">
</bean>


<bean id="useraction" class="spring.config.service.UserAction">
<property name="userDao" ref="userdao"></property>
</bean>


<bean id="useraction1" class="spring.config.service.UserAction1">
<constructor-arg index="0" ref="userdao"/>
<constructor-arg index="1" value="100" type="int"/>
</bean>


<bean id="messagebean"
class="spring.config.bean.MessageBean">

<property name="props">
<props>
<prop key="url">http://www.tom.com</prop>
<prop key="username">zhangsan</prop>
<prop key="password">123456789</prop>
</props>
</property>


<property name="books">
<map>
<entry key="10" value="CoreJava">
</entry>
<entry key="11" value="JavaWeb">
</entry>
<entry key="12" value="SSH2">
</entry>
</map>
</property>


<property name="friends">
<set>
<value>张三</value>
<value>李四</value>
<value>王五</value>
</set>
</property>


<property name="citys">
<list>
<value>北京</value>
<value>上海</value>
<value>深圳</value>
</list>
</property>


<property name="username">
<value>root</value>
</property>

<property name="password">
<value>1234</value>
</property>

<property name="size">
<value>15</value>
</property>
</bean>
</beans>

接下来呢，就是最后的测试类了：

package spring.config.test.ioc;

import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;

import spring.config.bean.MessageBean;
import spring.config.service.UserAction;
import spring.config.service.UserAction1;
/***
* 两种注入方式测试：
* @author Administrator
*1、采用setter方式注入
*2、采用constructs方式注入
*优缺点：
*1、setter方式注入：对构造器类型比较单一的，当指定参数不会参数冲突的可以用它，因为该方式
*没有参数类型的定义，<property name="" ref="" value=""></property>
*2、针对上述缺陷，有另一种构造器注入可以指定参数的类型
*<constructor-arg index="0" ref="userdao" type="int" value=""/>
*<constructor-arg index="1" ref="userdao" type="int" value=""/>
*state:success
*/
public class TestAction {
@Test
public void test(){
String configs = "src/spring/config/applicationContext.xml";
Resource r = new FileSystemResource(configs);
BeanFactory bf = new XmlBeanFactory(r);//bean元素工厂，他可以生产出类的实例
UserAction userAction =
(UserAction)bf.getBean("useraction");
userAction.register();
}

//@Test
public void test1(){
String configs = "src/spring/config/applicationContext.xml";
Resource r = new FileSystemResource(configs);
BeanFactory bf = new XmlBeanFactory(r);//bean元素工厂，他可以生产出类的实例
UserAction1 userAction1 =
(UserAction1)bf.getBean("useraction1");
userAction1.register();
}

/***
* 主要演示：
1、两张注入方式
2、复杂对象的property赋值设置
<property name="" ref="" value="">
<bean></bean>
<props></props>
<list></list>
<map></map>
<set></set>
</property>
* @author huawei
*
*/
//@Test
public void test2(){
String configs = "src/spring/config/applicationContext.xml";
Resource rs = new FileSystemResource(configs);
BeanFactory bf = new XmlBeanFactory(rs);
MessageBean msgBean =
(MessageBean)bf.getBean("messagebean");
msgBean.show();
}
}

csdn的编辑器真不好用，jar包未提供，很简单的例子。

beyond0851

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring使用之IOC配置篇

本计划分为四篇概括Spring常用的知识：IOC配置篇、AOP配置篇、IOC注解篇、AOP注解篇。Spring核心分为IOC和AOP，这两点在我的工作中经常使用，DI又是IOC的核心实现，理论不多说，程序只有测试通过才能是真正的理解入门，其他一切空谈。下面是接口：package spring.config.iInterface;public interface IUserD...
复制链接

扫一扫