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);
    }
}

/**
 * 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;
    }

}

/**
 * Supports pluggable strategies for alternate endpoint selection on
 * load balance.
 * <p/>
 * Random, Retries, Mod (later)
 * <p/>
 * 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);
}

            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;
            }

            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);

<?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/Hello</value>
        <value>http://localhost:8082/service/Hello</value>
        <value>http://localhost:8083/service/Hello</value>
        <value>http://localhost:8086/service/Hello</value>
        <value>http://localhost:8087/service/Hello</value>
        <value>http://localhost:8088/service/Hello</value>
    </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>

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 + " ===========================");
        }

}
}