Spring我来了!

java 代码

    spring是一种轻量级的框架,是为了更便于开发人员进行j2ee的企业级开发而应用而生的!最近开始学习spring在网上找了一个特别简单的例子,尽管很简单但是将spring的核心Ioc控制反转的作用体现了出来.下面的例子是一位网友的例子的基础上改进出来的!
1.建立javabean
类User

java 代码

1. package test.lht;   
2.   
3. public class User {       
4.     private String userName;       
5.     private int age;   
6.     public int getAge() {   
7.         return age;   
8.     }   
9.     public void setAge(int age) {   
10.         this.age = age;   
11.     }   
12.     public String getUserName() {       
13.         return userName;       
14.     }       
15.     public void setUserName(String userName) {       
16.         this.userName = userName;       
17.     }       
18. }    

类Address
java 代码

1. package test.lht;   
2.   
3. public class Address {   
4. private String city;   
5.   
6. public String getCity() {   
7.     return city;   
8. }   
9.   
10. public void setCity(String city) {   
11.     this.city = city;   
12. }   
13.   
14. }   

2.将javabean设置进applicationContext.xml中来实现分离

xml 代码

1.   
2.   
3. xml version="1.0" encoding="UTF-8"?>     从测试类可以看出加载了spring的配置文件后,将其封装为一个AplicationContext对象,然后由这个对象的getBean()方法来获取spring配置文件中定义的bean,这样没有采用ejb的方式利用复杂的配置文件和jndi来进行实现,而是将这些复杂的事情交给了容器来进行处理.
4. <beans xmlns="http://www.springframework.org/schema/beans"  
5.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
6.        xmlns:lang="http://www.springframework.org/schema/lang"  
7.        xsi:schemaLocation="   
8. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd   
9. http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-2.0.xsd">  
10.   
11.     <bean id="user" class="test.lht.User" abstract="false"      
12.        singleton="true" lazy-init="default" autowire="default"      
13.        dependency-check="default">      
14.        <property name="userName">      
15.            <value>hello liu heng taovalue>      
16.        property>      
17.        <property name="age">  
18.        <value>22value>  
19.        property>  
20.     bean>      
21.     <bean id="address" class="test.lht.Address" abstract="false"      
22.        singleton="true" lazy-init="default" autowire="default"      
23.        dependency-check="default">  
24.        <property name="city">  
25.        <value>xi'anvalue>  
26.          property>       
27.     bean>  
28.   
29. beans>  
30.   

<bean></bean>标签用于定义一个普通的javabean即POJO ,!
 3.测试类

1. package test.lht;   
2. //打眼一看怎么觉得不就是通过配置文件来将对象的创建和设置,隐式化了!一切都由spring框架来进行处理,而不是直接创建.   
3. import org.springframework.context.ApplicationContext;       
4. import org.springframework.context.support.FileSystemXmlApplicationContext;       
5. public class TestUser {       
6.     public static void main(String[] args) {       
7.          ApplicationContext context=new FileSystemXmlApplicationContext("/src/applicationContext.xml");    //获得配置文件   
8.         User user=(User)context.getBean("user");    //通过上下文对象获得名字为user的bean并专换成User类型   
9.         System.out.println("当前用户的名字是"+user.getUserName());   
10.         Address address=(Address)context.getBean("address");   
11.         System.out.println("当前用户的年龄是"+user.getAge());   
12.         System.out.println("当前用户所居住的城市"+address.getCity());   
13.         //这样就实现了注入的过程,而且值还可以通过配置文件进行设置,以往的ejb需要很多的文件来进行业务的处理,这里我们只需要简单的javabean进行   
14.         //实现就可以了.   
15.     }       
16. }    

 

简单的总结:
  这个简单的例子利用spring框架的控制反转(你不要调用我,我调用你!)的思想实现了对象创建的隐藏,不是有用户直接进行创建而是由容器来进行控制和管理!