springiocxml

1、导入spring的dist中的jar包和commons-logging包

2、在src目录下创建相应的beans.xml

3、为beans.xml添加相应的schema

<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-3.0.xsd">

</beans>

4、新建一个类

5、在beans.xml中创建对象

<!--

创建如下bean等于完成了:HelloWorld helloWorld = new HelloWorld

-->

6、在测试类中使用这个对象

6.1、创建Spring的工厂

private BeanFactory factory = new ClassPathXmlApplicationContext("beans.xml");

6.2、通过Spring工厂获取相应的对象

//此处getBean中的helloWorld就是beans.xml配置文件中的id

HelloWorld hello = factory.getBean("helloWorld",HelloWorld.class);

//此时的hello对象就是被Spring说管理的对象

System.out.println(hello.hello());

代码如下：

model:

package org.zttc.itat.spring.model;

public class User {

private int id;

private String username;

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public String getUsername() {

return username;

}

public void setUsername(String username) {

this.username = username;

}

public User() {

}

public User(int id, String username) {

super();

this.id = id;

this.username = username;

}

@Override

public String toString() {

return "User [id=" + id + ", username=" + username + "]";

}

dao:

//抽象类

package org.zttc.itat.spring.dao;

import org.zttc.itat.spring.model.User;

public interface IUserDao {

public void add(User user);

public void delete(int id);

public User load(int id);

}

//实现类

package org.zttc.itat.spring.dao;

import org.zttc.itat.spring.model.User;

public class UserDao implements IUserDao {

@Override

public void add(User user) {

System.out.println("添加了"+user);

}

@Override

public void delete(int id) {

System.out.println("delete :"+id);

}

@Override

public User load(int id) {

System.out.println("load:"+id);

return null;

}

service:

//抽象类

package org.zttc.itat.spring.service;

import org.zttc.itat.spring.model.User;

public interface IUserService {

public void add(User user);

public void delete(int id);

public User load(int id);

}

//实现类

package org.zttc.itat.spring.service;

import org.zttc.itat.spring.dao.IUserDao;

import org.zttc.itat.spring.model.User;

public class UserService implements IUserService {

//此处类是要依靠spring来注入的。

private IUserDao userDao;

//相应的get set 方法，这个必须有

public IUserDao getUserDao() {

return userDao;

}

public void setUserDao(IUserDao userDao) {

this.userDao = userDao;

}

@Override

public void add(User user) {

userDao.add(user);

}

@Override

public void delete(int id) {

userDao.delete(id);

}

@Override

public User load(int id) {

return userDao.load(id);

}

action：

package org.zttc.itat.spring.action;

import java.util.List;

import org.zttc.itat.spring.model.User;

import org.zttc.itat.spring.service.IUserService;

public class UserAction {

//此处四个也是要依赖spring的注入

private User user;

private IUserService userService;

private int id;

private List<String> names;

public List<String> getNames() {

return names;

}

public void setNames(List<String> names) {

this.names = names;

}

public IUserService getUserService() {

return userService;

}

public void setUserService(IUserService userService) {

this.userService = userService;

}

public UserAction() {

}

public UserAction(IUserService userService) {

super();

this.userService = userService;

}

public User getUser() {

return user;

}

public void setUser(User user) {

this.user = user;

}

//public IUserService getUserService() {

//return userService;

//}

//public void setUserService(IUserService userService) {

//this.userService = userService;

//}

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public void add() {

System.out.println(id);

System.out.println(names);

userService.add(user);

}

public void delete() {

userService.delete(id);

}

public void load() {

userService.load(id);

}

testSpring:

package org.zttc.itat.spring.test;

import org.junit.Test;

import org.springframework.beans.factory.BeanFactory;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.zttc.itat.spring.action.UserAction;

import org.zttc.itat.spring.model.HelloWorld;

import org.zttc.itat.spring.model.User;

public class TestSpring {

//创建Spring的工厂

private BeanFactory factory = new ClassPathXmlApplicationContext("beans.xml");

@Test

public void testHello() {

//通过工厂获取Spring的对象

//此处getBean中的helloWorld就是beans.xml配置文件中的id

//HelloWorld hello = (HelloWorld)factory.getBean("helloWorld");

HelloWorld hello = factory.getBean("helloWorld",HelloWorld.class);

//此时的hello对象就是被Spring说管理的对象

System.out.println(hello.hello());

HelloWorld hello2 = factory.getBean("helloWorld",HelloWorld.class);

//如果在bean中没有作scope的配置，默认是singleton（单例）,当把bean中的scope设置为prototype的时候就是多例

System.out.println(hello==hello2);

}

@Test

public void testUser01() {

UserAction ua1 = factory.getBean("userAction", UserAction.class);

User u = new User(1,"悟空");

ua1.setUser(u);

ua1.add();

UserAction ua2 = factory.getBean("userAction", UserAction.class);

ua2.add();

}

beam.xml：

<?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-3.0.xsd">

</bean>

<!-- 创建了一个userDao>

<!-- autowire=byName表示会根据name来完成注入，

byType表示根据类型注入 ,使用byType注入如果一个类中有两个同类型的对象就会抛出异常

所以在开发中一般都是使用byName

虽然自动注入可以减少配置，但是通过bean文件无法很好了解整个类的结果，所以不建议使用autowire-->

<!-- name中的值会在userService对象中调用setXX方法来注入，诸如:name="userDao"

在具体注入时会调用setUserDao(IUserDao userDao)来完成注入

ref="userDao"表示是配置文件中的bean中所创建的DAO的id -->

</bean>

<list>

</list>

</property>

</bean>

<!-- <bean id="userAction" class="org.zttc.itat.spring.action.UserAction" scope="prototype">

<constructor-arg ref="userService"/>

</bean> -->

</beans>