BlogJava-飞云小侠之风儿吹过-随笔分类-SOA

使用ZooKeeper为CXF或其他服务动态更新服务器信息

Scud(飞云小侠) — Sat, 16 Oct 2010 11:37:00 GMT

摘要: 使用ZooKeeper为CXF的负载均衡提供动态更新服务器列表. 也可以用于其他服务, 只要事先接口即可.

阅读全文

Scud(飞云小侠) 2010-10-16 19:37 发表评论

扩展CXF, 支持LoadBalance负载均衡

Scud(飞云小侠) — Fri, 15 Oct 2010 05:01:00 GMT

转载请注明作者和出处 http://scud.blogjava.net

CXF是一个比较流行的Web Service框架. ( 当然如果追求更高效, 还可以去搜索ice, thrift, protobuff之类的)

近一个月, 断断续续地又好好看了看CXF的一些代码, CXF的文档还是很欠缺,特别是关于内部实现的东西. 从我的感觉来说, 内部实现还是挺复杂的. Inteceptor, Feature, ConduitSelector 这些概念一大堆, 又差不多可以做类似的事情, 真是让人头晕.

CXF本身提供了一个FailoverFeature, 可以在调用服务出错时切换到其他服务器, 但是无法做到负载均衡, 我研究了几天, 在FailoverFeature的基础上改出来一个LoadBalanceFeature, 当然也同时支持Failover.

首先我们来看看如何使用CXF的FailoverFeature: (下载示例中包括使用xml和代码两种方式, 当然CXF自己还提供了使用wsdl内部定义的方式)

我们需要先准备一个HelloService, 非常简单的一个Web Service, 这里不在贴出, 具体可以看下载包
调用代码示例:

package org.javascud.extensions.cxf.testfailover;

import org.apache.cxf.clustering.FailoverFeature;
import org.apache.cxf.clustering.RandomStrategy;
import org.apache.cxf.feature.AbstractFeature;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import org.javascud.extensions.cxf.service.Hello;

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

public class HelloServiceFailOverClient
{
    public static void main(String[] args)
    {
        String helloFirst = "http://localhost:8080/service/Hello";
        String helloSecond = "http://localhost:8081/service/Hello";
        String helloThird = "http://localhost:8082/service/Hello";
        String helloFour = "http://localhost:8083/service/Hello";

        List<String> serviceList = new ArrayList<String>();
        serviceList.add(helloFirst);
        serviceList.add(helloSecond);
        serviceList.add(helloThird);
        //serviceList.add(helloFour);

        RandomStrategy strategy = new RandomStrategy();
        strategy.setAlternateAddresses(serviceList);

        FailoverFeature ff = new FailoverFeature();
        ff.setStrategy(strategy);

        JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();

        List<AbstractFeature> features = new ArrayList<AbstractFeature>();
        features.add(ff);

        factory.setFeatures(features);
        factory.initFeatures();

        factory.setServiceClass(Hello.class);
        //factory.setAddress("http://localhost:8080/service/Hello");

        Hello client = (Hello) factory.create();
        String result = client.sayHello("felix");
        System.out.println("result is: " + result);
    }
}

在遇到错误时可以自动使用下一个服务器, 但是必须要自己设置一个地址, 如果不设置的话也可以, 但是会出错然后failover.

下面我们自己来看看我们的 LoadBalanceFeature

1. 首先我们创建一个LoadBalanceFeature (完全和FailoverFeature一样)

Feature是用来定制Server, Client, Bus的一个组件, 具体可以查看AbstractFeature, 我们使用initialize方法来定制Client, 修改Client的Conduit选择器达到负载均衡的目的.

LoadBalanceFeature代码如下:

/**
* This feature may be applied to a Client so as to enable
* load balance , use any compatible endpoint for the target service.
*
* @author Felix Zhang   Date:2010-10-3 22:58
* @see org.apache.cxf.clustering.FailoverFeature
*/
public class LoadBalanceFeature extends AbstractFeature {
    private LoadBalanceStrategy loadBalanceStrategy;

    @Override
    public void initialize(Client client, Bus bus) {
        LoadBalanceTargetSelector selector = new LoadBalanceTargetSelector();
        selector.setEndpoint(client.getEndpoint());
        selector.setStrategy(getStrategy());
        client.setConduitSelector(selector);
    }

    public void setStrategy(LoadBalanceStrategy strategy) {
        loadBalanceStrategy = strategy;
    }

    public LoadBalanceStrategy getStrategy() {
        return loadBalanceStrategy;
    }

}

2. 定制一个LoadBalanceStrategy 负载均衡策略
负载均衡策略有很多种, 例如随机选择, 顺序选择等, FailoverFeature提供了三种策略, 总之很简单, 我们在这里就先实现随机策略, 其他的策略都很简单, 几行代码就可以实现了.

   这个类主要用来设置/获取所有的提供服务的地址列表, 为了方便控制, 我新增了2个选项:
   A: alwaysChangeEndpoint 是否每次请求都切换地址:　如果只有一个客户端, 可以分担负载. 缺省为true
   B: removeFailedEndpoint 是否从全局的地址列表中移除失败服务地址 -- 如果你没有监测服务器状态的程序

   关于动态增删服务地址

可以使用zookeeper等服务实时监测服务器状态, 或者自己写程序实现, 调用strategy.setAlternateAddresses即可.
removeFailedEndpoint 如果设置为true, 但没有监测服务器状态的程序, 新增的或者复活的服务器则无法被恢复到地址列表中.
考虑到效率和支持failover, 设置地址列表, 移除地址等没有同步锁.
自动移除失败服务地址时, 目前仅支持手动地址列表, 没有考虑wsdl中的多服务地址.
后续我会写一个使用zookeeper增删服务地址列表的示例. (最近也在看zookeeper)

主要的代码都在AbstractLoadBalanceStrategy 中, 基本和 AbstractStaticFailoverStrategy 一样, 添加了一个removeAlternateAddress 用于移除失败的服务地址.

LoadBalanceStrategy 接口的代码如下:

/**
* Supports pluggable strategies for alternate endpoint selection on
* load balance.
*

* Random, Retries, Mod (later)
*

* 1. support load balance  2.support fail over.
*
* @author Felix Zhang   Date:2010-10-1 18:14
* @see org.apache.cxf.clustering.FailoverStrategy
*/
public interface LoadBalanceStrategy {

    /**
     * Get the alternate endpoints for this invocation.
     *
     * @param exchange the current Exchange
     * @return a failover endpoint if one is available
     */
    List<Endpoint> getAlternateEndpoints(Exchange exchange);

    /**
     * Select one of the alternate endpoints for a retried invocation.
     *
     * @param alternates List of alternate endpoints if available
     * @return the selected endpoint
     */
    Endpoint selectAlternateEndpoint(List<Endpoint> alternates);

    /**
     * Get the alternate addresses for this invocation.
     * These addresses over-ride any addresses specified in the WSDL.
     *
     * @param exchange the current Exchange
     * @return a failover endpoint if one is available
     */
    List<String> getAlternateAddresses(Exchange exchange);

    /**
     * Select one of the alternate addresses for a retried invocation.
     *
     * @param addresses List of alternate addresses if available
     * @return the selected address
     */
    String selectAlternateAddress(List<String> addresses);

    /**
     * should remove failed endpoint or not.
     * only work for user defined addresses list.
     * @return true or false
     */
    boolean isRemoveFailedEndpoint();

    /**
     * change endpoint every time or not.
     * @return boolean
     */
    boolean isAlwaysChangeEndpoint();

    /**
     * remove failed address from list.
     * @param address the failed address
     */
    void removeAlternateAddress(String address);
}

   RandomLoadBalanceStrategy继承自 AbstractLoadBalanceStrategy, 和 RandomStrategy的区别就是获取下一个服务地址时并不从列表中移除此地址, 否则就做不到负载均衡了.

3. 最重要的 LoadBalanceTargetSelector
   A: 这个类比较复杂, 我们为了实现负载均衡, 修改了prepare来动态设置调用的endpoint, 替换策略取决于LoadBalanceStrategy
   主要代码如下:

            boolean existsEndpoint = false;
            //check current endpoint is not null
            Endpoint theEndpoint = exchange.get(Endpoint.class);
            if (theEndpoint.getEndpointInfo().getAddress() != null) {
                existsEndpoint = true;
            }

            Endpoint nextEndpoint;
            if (getStrategy().isAlwaysChangeEndpoint() || !existsEndpoint) {
                //get a endpoint and set to current endpoint
                Endpoint loadBalanceTarget = getLoadBalanceTarget(exchange);
                if (loadBalanceTarget != null) {
                    logger.info("switch to next target: " + loadBalanceTarget.getEndpointInfo().getAddress());
                    setEndpoint(loadBalanceTarget);

                    //update exchange.org.apache.cxf.message.Message.ENDPOINT_ADDRESS --- 不设置这个就用上次的奇怪
                    message.put(Message.ENDPOINT_ADDRESS, loadBalanceTarget.getEndpointInfo().getAddress());
                }

                nextEndpoint = loadBalanceTarget;
            } else {
                //use current endpoint
                nextEndpoint = theEndpoint;
            }

   B:为了和原有Failover特性兼容, 我们修改了 getFailoverTarget函数, 在此函数中要移除失败的服务地址, 因为在之前我们修改了LoadBalanceStrategy, 它在获取地址时不再移除当前地址, 所以我们需要手动移除.

   部分代码如下:

            String currentAddress = getEndpoint().getEndpointInfo().getAddress();

            //failover should remove current endpoint first, then get next -- 根据定义的策略来决定是否从全局地址列表中移除
            if (getStrategy().isRemoveFailedEndpoint()) {
                logger.warn("remove current failed address: " + currentAddress);
                //remove for client, not for current invocation -- 没有同步锁
                getStrategy().removeAlternateAddress(currentAddress);
            }

            //remove for current invocation: 当前请求中总是移除失败服务地址
            alternateAddresses.remove(currentAddress);

            String alternateAddress =
                    getStrategy().selectAlternateAddress(alternateAddresses);

4. 调用实例:

此处我们采用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"
       xmlns:jaxws="http://cxf.apache.org/jaxws"
       xmlns:clustering="http://cxf.apache.org/clustering"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

    <util:list id="addressList">
        <value>http://localhost:8081/service/Hellovalue>
        <value>http://localhost:8082/service/Hellovalue>
        <value>http://localhost:8083/service/Hellovalue>
        <value>http://localhost:8086/service/Hellovalue>
        <value>http://localhost:8087/service/Hellovalue>
        <value>http://localhost:8088/service/Hellovalue>
    util:list>

    <bean id="SequentialAddresses" class="org.apache.cxf.clustering.SequentialStrategy">
        <property name="alternateAddresses">
            <ref bean="addressList"/>
        property>
    bean>

    <bean id="randomAddresses" class="org.javascud.extensions.cxf.RandomLoadBalanceStrategy">
        <property name="alternateAddresses">
            <ref bean="addressList"/>
        property>
        <property name="removeFailedEndpoint" value="true" />
    bean>

    <bean id="loadBalanceFeature" class="org.javascud.extensions.cxf.LoadBalanceFeature">
        <property name="strategy" ref="randomAddresses" />
    bean>

    <jaxws:client name="helloClient"
                  serviceClass="org.javascud.extensions.cxf.service.Hello"            >
        <jaxws:features>
            <ref bean="loadBalanceFeature" />
        jaxws:features>
    jaxws:client>

beans>

8081, 8082, 8083是实际存在的服务, 其他的不存在.

调用的Java代码:

package org.javascud.extensions.cxf.loadbalance;

import org.apache.cxf.endpoint.Client;
import org.apache.cxf.frontend.ClientProxy;
import org.javascud.extensions.cxf.LoadBalanceStrategy;
import org.javascud.extensions.cxf.service.Hello;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloLoadBalanceAndFailOverClientByXML
{
    public static void main(String[] args)
    {
        ClassPathXmlApplicationContext context
                = new ClassPathXmlApplicationContext(new String[]
                {"org/javascud/extensions/cxf/loadbalance/loadbalance_fail.xml"});
        Hello client = (Hello) context.getBean("helloClient");

        LoadBalanceStrategy strategy = (LoadBalanceStrategy) context.getBean("randomAddresses");

        Client myclient = ClientProxy.getClient(client);
        String address = myclient.getEndpoint().getEndpointInfo().getAddress();

        System.out.println(address);

        for(int i=1; i<=20; i++)
        {
            String result1 = client.sayHello("Felix" +i);
            System.out.println("Call " + i +": " + result1);

            int left = strategy.getAlternateAddresses(null).size();
            System.out.println("================== left " + left + " ===========================");
        }

    }
}

    此处仅仅为模拟测试.

5. 关于测试用例
   没想好如何写单元测试, test里面目前都是随意测试的代码, 基本照顾到所有功能.



6. 下载
代码下载: http://cnscud.googlecode.com/files/extensions-cxf_20101015.zip
源码位置: http://cnscud.googlecode.com/svn/trunk/extensions/ 其中cxf目录是此文章相关的源码.

7. 有任何问题请留言.

转载请注明作者和出处 http://scud.blogjava.net

Scud(飞云小侠) 2010-10-15 13:01 发表评论

CXF restful webserice同时支持几种协议 json, xml... 很简单

Scud(飞云小侠) — Mon, 19 Jul 2010 16:30:00 GMT

1. 假设我们有个服务 (都是从别处拿来的代码)

mport javax.ws.rs.*;
import javax.ws.rs.core.Response;

@Path(value = "/student/{id}")
public interface StudentService
{
    @GET
    @Path(value = "/info")
    Student getStudent(@PathParam("id") long id, @QueryParam("name")
    String name);

    @GET
    @Path(value = "/info2")
    UserResponse getStudent(@QueryParam("name") String name);
}

服务实现类:

import javax.ws.rs.core.Response;
import java.text.ParseException;
import java.text.SimpleDateFormat;

public class StudentServiceImpl implements StudentService
{
    public Student getStudent(long id, String name)
    {
        Student s = new Student();
        s.setId(id);
        s.setName(name);
        try
        {
            s.setBirthday(new SimpleDateFormat("yyyy-MM-dd").parse("1983-04-26"));
        }
        catch (ParseException e)
        {
            e.printStackTrace();
        }
        return s;
    }

    public Response getStudent1(String name)
    {
        Student s = new Student();
        s.setId(1);
        s.setName(name);
        try
        {
            s.setBirthday(new SimpleDateFormat("yyyy-MM-dd").parse("1983-04-26"));
        }
        catch (ParseException e)
        {
            e.printStackTrace();
        }

        return Response.ok(s).build();
        //return s;
    }

    public UserResponse getStudent(String name)
    {
        Student s = new Student();
        s.setId(1);
        s.setName(name);
        try
        {
            s.setBirthday(new SimpleDateFormat("yyyy-MM-dd").parse("1983-04-26"));
        }
        catch (ParseException e)
        {
            e.printStackTrace();
        }

        return new UserResponse("ok", s);
    }

返回数据包装类

import javax.xml.bind.annotation.*;

@XmlRootElement(name = "Response")
@XmlAccessorType(XmlAccessType.FIELD)
public class UserResponse
{
    private String status;

    private Student data;

    public UserResponse()
    {
    }

    public UserResponse(String status, Student data)
    {
        this.status = status;
        this.data = data;
    }

    public String getStatus()
    {
        return status;
    }

    public void setStatus(String status)
    {
        this.status = status;
    }

    public Object getData()
    {
        return data;
    }

    public void setData(Student data)
    {
        this.data = data;
    }
}

普通类

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;
import java.util.Date;

@XmlRootElement(name = "Student")
@XmlAccessorType(XmlAccessType.FIELD)
public class Student
{
    private long id;
    private String name;
    private Date birthday;

    public long getId()
    {
        return id;
    }

    public void setId(long id)
    {
        this.id = id;
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public Date getBirthday()
    {
        return birthday;
    }

    public void setBirthday(Date birthday)
    {
        this.birthday = birthday;
    }
}

Spring 服务声明

    <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"/>
    <import resource="classpath:META-INF/cxf/cxf-extension-jaxrs-binding.xml"/>

    <bean id="rsStudentServiceImpl" class="ex3.StudentServiceImpl" />

    <jaxrs:server id="test" address="/student" >
        <jaxrs:serviceBeans>
            <ref bean="rsStudentServiceImpl" />
        jaxrs:serviceBeans>


        <jaxrs:extensionMappings>
          <entry key="json" value="application/json"/>
          <entry key="xml" value="application/xml"/>
        jaxrs:extensionMappings>
    jaxrs:server>

web.xml 就不贴了, 和普通的一样.

2. 访问方法有3种, 可以实现获取不同格式的内容.

http://localhost:8080/student/student/3/info2.json?name=abcss
http://localhost:8080/student/student/3/info2.xml?name=abcss

http://localhost:8080/student/student/3/info2?name=abcss&_type=xml
http://localhost:8080/student/student/3/info2?name=abcss&_type=json

还有一种办法就是在请求时设置Accept:

        HttpGet get = new HttpGet(
                "http://127.0.0.1:8080/student/student/3/info2?name=Fetion");
        HttpClient httpclient = new DefaultHttpClient();

        get.addHeader("ACCEPT", "application/xml");

        HttpResponse response = httpclient.execute(get);

        StatusLine st = response.getStatusLine();

    InputStream ins = response.getEntity().getContent();
    byte[] b = new byte[1024];
    StringBuilder sb = new StringBuilder();
    while (ins.read(b) != -1)
    {
        sb.append(new String(b, "UTF-8"));
    }
    System.out.println(sb.toString());

简单吧.... 呵呵

Scud(飞云小侠) 2010-07-20 00:30 发表评论