spring三种实例化bean的方式

在spring中有三中实例化bean的方式：

一、使用构造器实例化；

二、使用静态工厂方法实例化；

三、使用实例化工厂方法实例化。

 

每种实例化所采用的配置是不一样的：

一、使用构造器实例化；

这种实例化的方式可能在我们平时的开发中用到的是最多的，因为在xml文件中配置简单并且也不需要额外的工厂类来实现。

面向切面编程（AOP）通过提供另外一种思考程序结构的途经来弥补面向对象编程（OOP）的不足。在OOP中模块化的关键单元是类（classes），而在AOP中模块化的单元则是切面。切面能对关注点进行模块化，例如横切多个类型和对象的事务管理。（在AOP术语中通常称作横切（crosscutting）关注点。）

AOP框架是Spring的一个重要组成部分。但是Spring IoC容器并不依赖于AOP，这意味着你有权利选择是否使用AOP，AOP做为Spring IoC容器的一个补充,使它成为一个强大的中间件解决方案。

AOP在Spring Framework中的作用

目前AOP主要有：Spring AOP ,JBOSS AOP ,AspectJ AOP

AOP与OOP：可以理解为OOP是纵向的采用继承树形式的。而AOP是横向的

Spring AOP:

AspectJ AOP:

面向切面编程，把散落在程序中的公共部分提取出来，做成切面类，这样的好处在于，代码的可重用，一旦涉及到该功能的需求发生变化，只要修改该代码就行，否则，你要到处修改，如果只要修改1、2处那还可以接受，万一有1000处呢。 
AOP底层的东西就是JDK动态代理和CGLIB代理，说白了就是增强类的功能。 
最常用的AOP应用在数据库连接以及事务处理上。

AOP:面向切面编程。（Aspect-Oriented Programming）
AOP可以说是对OOP的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。
将程序中的交叉业务逻辑（比如安全，日志，事务等），封装成一个切面，然后注入到目标对象（具体业务逻辑）中去。

实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码.

 AOP（Aspect Orient Programming），作为面向对象编程的一种补充，广泛应用于处理一些具有横切性质的系统级服务，如事务管理、安全检查、缓存、对象池管理等。 AOP 实现的关键就在于 AOP 框架自动创建的 AOP 代理，AOP 代理则可分为静态代理和动态代理两大类，其中静态代理是指使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，因此也称为编译时增强；而动态代理则在运行时借助于 JDK 动态代理、CGLIB 等在内存中"临时"生成 AOP 动态代理类，因此也被称为运行时增强。

使用IoC，对象是被动的接受依赖类，而不是自己主动的去找。容器在实例化的时候主动将它的依赖类注入给它。可以这样理解：控制反转将类的主动权转移到接口上，依赖注入通过xml配置文件在类实例化时将其依赖类注入。

控制反转即IoC (Inversion of Control)，它把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。所谓的“控制反转”概念就是对组件对象控制权的转移，从程序代码本身转移到了外部容器。

依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。具体含义是:当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，因此称为控制反转;创建被调用者实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。
  简而言之：所谓控制反转就是应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护是由外部容器负责的。这样控制权就由应用转移到了外部容器，控制权的转移就是所谓反转；所谓依赖注入就是指：在运行期，由外部容器动态地将依赖对象注入到组件中。

IoC核心理念：

1.在类当中不创建对象，在代码中不直接与对象和服务连接

2.在配置文件中描述创建对象的方式，以及各个组件之间的联系

3.外部容器通过解析配置文件，通过反射来将这些联系在一起

The Hollywood principle：Don’t call us,we’ll call you.

即，所有组件都是被动的、不主动联系（调用）外部代码，

要等着外部代码的调用--------所有的组件的初始化和相互调用都由容器负责实现。

简单的说，就是整个程序之间的关系，都由容器来控制:将程序的控制权反转给容器,就是所谓的外转

而在我们传统代码中，由程序代码直接控制

  IOC的意思是控件反转也就是由容器控制程序之间的关系，把控件权交给了外部容器，之前的写法，由程序代码直接操控，而现在控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。

ApplicationContext包括BeanFactory的全部功能，因此建议优先使用ApplicationContext。除非对于某些内存非常关键的应用，才考虑使用 BeanFactory。

spring为ApplicationContext提供的3种实现分别为：

1、  ClassPathXmlApplicationContext：利用类路径的XML文件来载入Bean定义的信息

[1]  ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");

[2]  String[] locations = {"bean1.xml", "bean2.xml", "bean3.xml"};

ApplicationContext ctx = new ClassPathXmlApplication(locations);

2、 FileSystemXmlApplicationContext：利用文件系统中的XMl文件来载入Bean

定义的信息

[1]  ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml"); //加载单个配置文件

[2]  String[] locations = {"bean1.xml", "bean2.xml", "bean3.xml"};

 ApplicationContext ctx = new FileSystemXmlApplicationContext(locations );

//加载多个配置文件

[3]  ApplicationContext ctx =new FileSystemXmlApplicationContext("D:/project/bean.xml");

//根据具体路径加载

3、 XmlWebApplicationContext：从Web系统中的XML文件来载入Bean定义的信息。

 ServletContext servletContext = request.getSession().getServletContext();    

 ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext);

配置WebApplicationContext的两种方法：

（1）        利用Listener接口来实现

<listener>

       <listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

<context-param>

       <param-name>contextConfigLocation</param-name>

       <param-value>classpath:applicationContext</param-value>

</context-param>

（2）        利用Servlet接口来实现

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:applicationContext</param-value>

</context-param>

<Servlet>

       <servlet-name>context</servlet-name>

       <servlet-class>

           org.springframework.web.context.ContextLoaderServlet

       </servlet-class>

</servlet>

• 装载

1. 实例化; 
2. 设置属性值; 
3. 如果实现了BeanNameAware接口,调用setBeanName设置Bean的ID或者Name; 
4. 如果实现BeanFactoryAware接口,调用setBeanFactory 设置BeanFactory; 
5. 如果实现ApplicationContextAware,调用setApplicationContext设置ApplicationContext 
6. 调用BeanPostProcessor的预先初始化方法; 
7. 调用InitializingBean的afterPropertiesSet()方法; 
8. 调用定制init-method方法； 
9. 调用BeanPostProcessor的后初始化方法;

• spring容器关闭

1. 调用DisposableBean的destroy(); 
2. 调用定制的destroy-method方法;

二，多个Bean的先后顺序

• 优先加载BeanPostProcessor的实现Bean
• 按Bean文件和Bean的定义顺序按bean的装载顺序（即使加载多个spring文件时存在id覆盖）
• “设置属性值”（第2步）时，遇到ref，则在“实例化”（第1步）之后先加载ref的id对应的bean
• AbstractFactoryBean的子类，在第6步之后,会调用createInstance方法，之后会调用getObjectType方法
• BeanFactoryUtils类也会改变Bean的加载顺序

<?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:aop="http://www.springframework.org/schema/aop"
 xmlns:cache="http://www.springframework.org/schema/cache"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:oxm="http://www.springframework.org/schema/oxm"
 xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd 
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd 
    http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd">
 <!-- 指定系统寻找controller路径 -->
 <!-- json 数据格式转换
 <mvc:annotation-driven>
  <mvc:message-converters>
   <bean id="jsonConverter" class="com.abin.lee.ssh.util.json.fastjson.FastjsonHttpMessageConverter">
    <property name="supportedMediaTypes" value="application/json" />
    <property name="serializerFeature">
     <list>
      <value>WriteMapNullValue</value>
      <value>QuoteFieldNames</value>
     </list>
    </property>
   </bean>
  </mvc:message-converters>

 </mvc:annotation-driven>
 -->
 <!-- 搜索的包路径 -->
 <context:component-scan base-package="com.abin.lee.ssh"
  use-default-filters="false">
  <context:include-filter type="annotation"
   expression="org.springframework.stereotype.Controller" />
 </context:component-scan>
 
 <!-- jsp视图解释器 -->
 <bean id="jspViewResolver"
  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  <property name="viewClass"
   value="org.springframework.web.servlet.view.JstlView" />
  <property name="prefix" value="/page/" />
  <property name="suffix" value=".jsp" />
 </bean>
 
</beans>

package com.abin.lee.ssh.controller;

import java.util.ArrayList;
import java.util.List;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;

import com.abin.lee.ssh.entity.UniversalBean;
@Scope("prototype")
@Controller
@RequestMapping("/sky/")
public class UniversalController {
 
 @RequestMapping("/activity")
 public String activity(ModelMap map){
  List<UniversalBean> list=new ArrayList<UniversalBean>();
  UniversalBean bean=null;
  for(int i=0;i<=5;i++){
   bean=new UniversalBean();
   bean.setId(i);
   bean.setName("abin"+i);
   bean.setImageUrl("http://localhost:7700/front/"+i+".jpg");
   list.add(bean);
  }
  map.put("list", list);
  return "mobile/show";
 }

}

Spring AOP使用了两种代理机制，一种是基于JDK的动态代理，另一种是基于CGLib的动态代理，之所以需要两种代理机制，很大程度上是因为JDK本身只提供基于接口的代理，不支持类的代理。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
 id="WebApp_ID" version="3.0">
 <display-name>universal</display-name>
 <!-- spring -->
 <context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath*:com/abin/lee/ssh/spring-service.xml</param-value>
 </context-param>
 <listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>

 <!-- spring MVC -->
 <servlet>
  <servlet-name>spring-mvc</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <init-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>classpath*:com/abin/lee/ssh/spring-mvc.xml</param-value>
  </init-param>
  <load-on-startup>2</load-on-startup>
 </servlet>
 <servlet-mapping>
  <servlet-name>spring-mvc</servlet-name>
  <url-pattern>/mvc/*</url-pattern>
 </servlet-mapping>
 <!-- spring encoding -->
 <filter>
  <filter-name>utf8-encoding</filter-name>
  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  <init-param>
   <param-name>encoding</param-name>
   <param-value>utf-8</param-value>
  </init-param>
  <init-param>
   <param-name>forceEncoding</param-name>
   <param-value>true</param-value>
  </init-param>
 </filter>
 <filter-mapping>
  <filter-name>utf8-encoding</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>

 <welcome-file-list>
  <welcome-file>index.html</welcome-file>
  <welcome-file>index.htm</welcome-file>
  <welcome-file>index.jsp</welcome-file>
  <welcome-file>default.html</welcome-file>
  <welcome-file>default.htm</welcome-file>
  <welcome-file>default.jsp</welcome-file>
 </welcome-file-list>
</web-app>

<?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:aop="http://www.springframework.org/schema/aop"
 xmlns:cache="http://www.springframework.org/schema/cache"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:oxm="http://www.springframework.org/schema/oxm"
 xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd 
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd 
    http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd">
 <!-- 指定系统寻找controller路径 -->
 <mvc:annotation-driven>
  <!-- json 数据格式转换-->
  <mvc:message-converters>
   <bean class="com.abin.lee.ssh.function.FastJsonAbstractHttpMessageConverter">
    <property name="supportedMediaTypes" value="application/json" />
    <property name="serializerFeature">
     <list>
      <value>WriteMapNullValue</value>
      <value>QuoteFieldNames</value>
     </list>
    </property>
   </bean>
  </mvc:message-converters>

 </mvc:annotation-driven>
 <!-- 搜索的包路径 -->
 <context:component-scan base-package="com.abin.lee.ssh"
  use-default-filters="false">
  <context:include-filter type="annotation"
   expression="org.springframework.stereotype.Controller" />
 </context:component-scan>

</beans>

package com.abin.lee.ssh.function;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.URLDecoder;
import java.nio.charset.Charset;

import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.AbstractHttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.util.FileCopyUtils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;

//来对requestbody 或responsebody中的数据进行解析
public class FastJsonAbstractHttpMessageConverter extends AbstractHttpMessageConverter<Object>{
  public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
 // fastjson特性参数 
    private SerializerFeature[] serializerFeature; 
 
    public SerializerFeature[] getSerializerFeature() { 
        return serializerFeature; 
    } 
 
    public void setSerializerFeature(SerializerFeature[] serializerFeature) { 
        this.serializerFeature = serializerFeature; 
    } 
 
 //限定页面文本传送类型 只有数据是改类型 的 才会进行拦截
 //application/json
 public FastJsonAbstractHttpMessageConverter(){
//  super(new MediaType("text","plain"));
  super(new MediaType("application","json"));
 }
 @Override
 protected Object readInternal(Class<? extends Object> clazz, HttpInputMessage inputmessage) throws IOException,
   HttpMessageNotReadableException {
  Charset charset;
  MediaType mediaType=inputmessage.getHeaders().getContentType();
  if(mediaType!=null&&mediaType.getCharSet()!=null){
   charset=mediaType.getCharSet();
  }else{
   charset=Charset.forName("UTF-8");
  }
  
  String input=FileCopyUtils.copyToString(new InputStreamReader(inputmessage.getBody(),charset));
  String result=URLDecoder.decode(input, "UTF-8");
  System.out.println(result);
  /*OrgnizationPO po=new OrgnizationPO();
  po.setId(1);
  po.setName("11");
  po.setOrgdesc("1");*/
  
  /*ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
        int i; 
        while ((i = inputmessage.getBody().read()) != -1) { 
            baos.write(i); 
        }  */
        return JSON.parseObject(result, clazz);
//        return JSON.parseArray(baos.toString(), clazz);
//  return po;
 }

 @Override
 protected boolean supports(Class<?> clazz) {
  return true;
  //throw new UnsupportedOperationException();
 }

 @Override
 protected void writeInternal(Object o, HttpOutputMessage outputMessage) throws IOException,
   HttpMessageNotWritableException {
  String jsonString = JSON.toJSONString(o, serializerFeature); 
//  System.out.println(jsonString);
        OutputStream out = outputMessage.getBody(); 
        out.write(jsonString.getBytes(DEFAULT_CHARSET)); 
        out.flush(); 
 }

}

package com.abin.lee.ssh.hibernate;

import com.abin.lee.ssh.entity.ModeBean;

public interface ModeDao {
 public boolean insert(ModeBean mode);
}

package com.abin.lee.ssh.hibernate.impl;

import javax.annotation.Resource;

import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;

import com.abin.lee.ssh.entity.ModeBean;
import com.abin.lee.ssh.hibernate.ModeDao;
@Repository
public class ModeDaoImpl extends HibernateDaoSupport implements ModeDao{
 
 @Resource(name = "sessionFactory")
 public void setSuperSessionFactory(SessionFactory sessionFactory) {
  super.setSessionFactory(sessionFactory);
 }
 
 public boolean insert(ModeBean mode) {
  boolean flag=false;
  try {
   this.getHibernateTemplate().saveOrUpdate(mode);
   flag=true;
  } catch (Exception e) {
   e.printStackTrace();
  }
  return flag;
 }
 
 
}

package com.abin.lee.ssh.spring;

import com.abin.lee.ssh.entity.ModeBean;

public interface ModeService {
 public boolean insert(ModeBean mode);

}

package com.abin.lee.ssh.spring.impl;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.abin.lee.ssh.entity.ModeBean;
import com.abin.lee.ssh.hibernate.ModeDao;
import com.abin.lee.ssh.spring.ModeService;

@Service
@Transactional(readOnly = true, timeout = 2, propagation = Propagation.SUPPORTS, isolation = Isolation.READ_COMMITTED, rollbackFor = Exception.class)
public class ModeServiceImpl implements ModeService {
 @Resource
 private ModeDao modeDao;

 @Transactional(readOnly = false, propagation = Propagation.REQUIRED)
 public boolean insert(ModeBean mode) {
  boolean flag = false;
  try {
   flag = this.modeDao.insert(mode);
  } catch (Exception e) {
   e.printStackTrace();
  }
  return flag;
 }

}

package com.abin.lee.ssh.springmvc;

import javax.annotation.Resource;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.abin.lee.ssh.dto.request.ModeRequest;
import com.abin.lee.ssh.dto.response.ModeResponse;
import com.abin.lee.ssh.entity.ModeBean;
import com.abin.lee.ssh.spring.ModeService;

@Controller
@RequestMapping("/stevenjohn/")
public class ModeController {
 @Resource
 private ModeService modeService;

 @RequestMapping(value = "getMode", method = RequestMethod.POST)
 public @ResponseBody
 ModeResponse getMode(
   @ModelAttribute ModeRequest modeRequest) {
  ModeResponse response = new ModeResponse();
  String id=modeRequest.getId();
  String username=modeRequest.getUsername();
  String password=modeRequest.getPassword();
  int age=modeRequest.getAge();
  String address=modeRequest.getAddress();
  String email=modeRequest.getEmail();
  ModeBean mode=new ModeBean(id, username, password, age, address, email);
  boolean flag=modeService.insert(mode);
  System.out.println("flag="+flag);
  if(flag==true){
   response.setStatus("success");
  }else{
   response.setStatus("failure");
  }
  
  return response;
 }
}

package com.abin.lee.ssh.entity;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="MODEBEAN")
public class ModeBean implements Serializable{
 @Id
 @Column(name="ID")
 private String id;
 @Column(name="USERNAME",length=100,nullable=true)
 private String username;
 @Column(name="PASSWORD",length=100,nullable=true)
 private String password;
 @Column(name="AGE",length=10,nullable=true)
 private int age;
 @Column(name="ADDRESS",length=100,nullable=true)
 private String address;
 @Column(name="EMAIL",length=100,nullable=true)
 private String email;
 public ModeBean() {
 }
 public ModeBean(String id, String username, String password, int age,
   String address, String email) {
  super();
  this.id = id;
  this.username = username;
  this.password = password;
  this.age = age;
  this.address = address;
  this.email = email;
 }
 
 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public String getUsername() {
  return username;
 }
 public void setUsername(String username) {
  this.username = username;
 }
 public String getPassword() {
  return password;
 }
 public void setPassword(String password) {
  this.password = password;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getAddress() {
  return address;
 }
 public void setAddress(String address) {
  this.address = address;
 }
 public String getEmail() {
  return email;
 }
 public void setEmail(String email) {
  this.email = email;
 }
 
 
}

package com.abin.lee.ssh.dto.request;

import java.io.Serializable;

public class ModeRequest implements Serializable{
 /**
  *
  */
 private static final long serialVersionUID = 1886596479119297989L;
 private String id;
 private String username;
 private String password;
 private int age;
 private String address;
 private String email;
 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public String getUsername() {
  return username;
 }
 public void setUsername(String username) {
  this.username = username;
 }
 public String getPassword() {
  return password;
 }
 public void setPassword(String password) {
  this.password = password;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getAddress() {
  return address;
 }
 public void setAddress(String address) {
  this.address = address;
 }
 public String getEmail() {
  return email;
 }
 public void setEmail(String email) {
  this.email = email;
 }
 
}

package com.abin.lee.ssh.dto.response;

import java.io.Serializable;

public class ModeResponse implements Serializable{
 /**
  *
  */
 private static final long serialVersionUID = 7725619232731203410L;
 private String status;
 private String message;
 public ModeResponse() {
 }
 public ModeResponse(String status, String message) {
  super();
  this.status = status;
  this.message = message;
 }
 public String getStatus() {
  return status;
 }
 public void setStatus(String status) {
  this.status = status;
 }
 public String getMessage() {
  return message;
 }
 public void setMessage(String message) {
  this.message = message;
 }
 
}

log4j.rootCategory=info,log,console

log4j.logger.org.apache.axis2.enterprise=FATAL
log4j.logger.de.hunsicker.jalopy.io=FATAL
log4j.logger.httpclient.wire.header=FATAL
log4j.logger.org.apache.commons.httpclient=FATAL

log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d [%t] %-5p %c %x - %m%n
 
log4j.appender.log=org.apache.log4j.DailyRollingFileAppender
log4j.appender.log.File=../logs/mms.log
log4j.appender.log.layout=org.apache.log4j.PatternLayout
log4j.appender.log.layout.ConversionPattern=%d [%t] %-5p %c %x - %m%n

package com.abin.lee.ssm;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import junit.framework.TestCase;

import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.junit.Test;

public class HttpsClient extends TestCase {
 private String httpUrl = "http://localhost:7000/universal/mvc/stevenjohn/getMode";

 @Test
 public void testHttpsClient() {
  try {
   HttpClient httpClient = new DefaultHttpClient();
   HttpPost httpPost = new HttpPost(httpUrl);
   List<NameValuePair> nvps = new ArrayList<NameValuePair>();
   nvps.add(new BasicNameValuePair("id", UUID.randomUUID().toString()));
   nvps.add(new BasicNameValuePair("username", "abin"));
   nvps.add(new BasicNameValuePair("password", "abing"));
   nvps.add(new BasicNameValuePair("age", "28"));
   nvps.add(new BasicNameValuePair("address", "beijing of china"));
   nvps.add(new BasicNameValuePair("email", "varyall@tom.com"));
   httpPost.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
   HttpResponse httpResponse = httpClient.execute(httpPost);
   BufferedReader buffer = new BufferedReader(new InputStreamReader(
     httpResponse.getEntity().getContent()));
   StringBuffer stb=new StringBuffer();
   String line=null;
   while((line=buffer.readLine())!=null){
    stb.append(line);
   }
   buffer.close();
   String result=stb.toString();
   System.out.println("result="+result);
  } catch (Exception e) {
   e.printStackTrace();
  }

 }

}

import javax.jws.WebService;

/**
 * @author abin
 *
 */
@WebService(targetNamespace="cxf.lee.abin.com")
public interface IUserService {
 public String getMessage(String message);
}

package com.abin.lee.cxf;

import javax.jws.WebService;

@WebService(endpointInterface="com.abin.lee.cxf.IUserService")
public class UserService implements IUserService{

 public String getMessage(String message) {
  return message+" welcome to beijing";
 }
 
}

<?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:context="http://www.springframework.org/schema/context"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:jaxws="http://cxf.apache.org/jaxws"
 xmlns:cxf="http://cxf.apache.org/core"
 xmlns:wsa="http://cxf.apache.org/ws/addressing"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/tx
 http://www.springframework.org/schema/tx/spring-beans-3.0.xsd
 http://cxf.apache.org/core
 http://cxf.apache.org/schemas/core.xsd
 http://cxf.apache.org/jaxws
 http://cxf.apache.org/schemas/jaxws.xsd
 http://www.springframework.org/schema/aop
 http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 <import resource="classpath:META-INF/cxf/cxf.xml" />
 <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
 <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
 
 <cxf:bus>
  <cxf:features>
   <!--日志拦截功能，用于监控soap内容，开发后可以删除 -->
   <cxf:logging/>
   <wsa:addressing/>
  </cxf:features>
 </cxf:bus> 

 <bean id="userService" class="com.abin.lee.cxf.UserService"></bean>
 <jaxws:endpoint id="userWebservice" implementor="#userService" address="/UserService" publish="true" />

</beans>

package com.abin.lee.spring;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 *
 * 获取spring容器，以访问容器中定义的其他bean
 *
 * @author lyltiger
 * @since MOSTsView 3.0 2009-11-16
 */
public class SpringContextUtil implements ApplicationContextAware {

 // Spring应用上下文环境
 private static ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
   "com/abin/lee/cxf/applicationContext-cxf.xml");

 /**
  * 实现ApplicationContextAware接口的回调方法，设置上下文环境
  *
  * @param applicationContext
  */
 public void setApplicationContext(ApplicationContext applicationContext) {
  SpringContextUtil.applicationContext = applicationContext;
 }

 /**
  * @return ApplicationContext
  */
 public static ApplicationContext getApplicationContext() {
  return applicationContext;
 }

 /**
  * 获取对象 这里重写了bean方法，起主要作用
  *
  * @param name
  * @return Object 一个以所给名字注册的bean的实例
  * @throws BeansException
  */
 public static Object getBean(String name) throws BeansException {
  return applicationContext.getBean(name);
 }

}

package com.abin.lee.cxf.test;

import com.abin.lee.cxf.UserService;
import com.abin.lee.spring.SpringContextUtil;

import junit.framework.TestCase;

public class TestUserService extends TestCase{
 public void testcxf(){
  UserService userService=(UserService)SpringContextUtil.getBean("userService");
  
  String response=userService.getMessage("abin");
  System.out.println("response="+response);
  System.exit(0);
 }
}

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 *
 * 获取spring容器，以访问容器中定义的其他bean
 *
 * @author lyltiger
 * @since MOSTsView 3.0 2009-11-16
 */
public class SpringContextUtil implements ApplicationContextAware {

 // Spring应用上下文环境
 private static ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
   "com/abin/lee/spring/applicationContext-queue.xml");

 /**
  * 实现ApplicationContextAware接口的回调方法，设置上下文环境
  *
  * @param applicationContext
  */
 public void setApplicationContext(ApplicationContext applicationContext) {
  SpringContextUtil.applicationContext = applicationContext;
 }

 /**
  * @return ApplicationContext
  */
 public static ApplicationContext getApplicationContext() {
  return applicationContext;
 }

 /**
  * 获取对象 这里重写了bean方法，起主要作用
  *
  * @param name
  * @return Object 一个以所给名字注册的bean的实例
  * @throws BeansException
  */
 public static Object getBean(String name) throws BeansException {
  return applicationContext.getBean(name);
 }

}

package com.abin.lee.queue;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class BeanFactoryUtil {
 private static BeanFactory factory = new XmlBeanFactory(
   new ClassPathResource(
     "com/abin/lee/spring/applicationContext-queue.xml"));

 public static BeanFactory getFactory() {
  return factory;
 }

 public static void setFactory(BeanFactory factory) {
  BeanFactoryUtil.factory = factory;
 }
 
 public static Object getBean(String name){
  return factory.getBean(name);
 }
}

package com.abin.lee.queue;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.Map;

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class QueueServlet extends HttpServlet{
 
 protected void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  Map map=request.getParameterMap();
  String name1=(String)((Object[])map.get("name1"))[0];
  String name2=(String)((Object[])map.get("name2"))[0];
  MakeQueue makeQueue = (MakeQueue)BeanFactoryUtil.getBean("makeQueue");//bean的名称
  System.out.println(makeQueue.queueSize());
  makeQueue.addQueue(name1);
  makeQueue.addQueue(name2);
  System.out.println(makeQueue.queueSize());
  
  ServletOutputStream out=response.getOutputStream();
  BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(out));
  writer.write("success");
  writer.flush();
  writer.close();
 }
}