限制IP注册到Eureka

importjava.util.List;

importcom.netflix.eureka.lease.Lease;
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
importorg.springframework.beans.BeansException;
importorg.springframework.cloud.netflix.eureka.server.event.EurekaInstanceCanceledEvent;
importorg.springframework.cloud.netflix.eureka.server.event.EurekaInstanceRegisteredEvent;
importorg.springframework.cloud.netflix.eureka.server.event.EurekaInstanceRenewedEvent;
importorg.springframework.context.ApplicationContext;
importorg.springframework.context.ApplicationContextAware;

importcom.netflix.appinfo.ApplicationInfoManager;
importcom.netflix.appinfo.InstanceInfo;
importcom.netflix.discovery.EurekaClient;
importcom.netflix.discovery.EurekaClientConfig;
importcom.netflix.discovery.shared.Application;
importcom.netflix.eureka.EurekaServerConfig;
importcom.netflix.eureka.registry.PeerAwareInstanceRegistryImpl;
importcom.netflix.eureka.resources.ServerCodecs;
importorg.springframework.context.ApplicationEvent;
importorg.springframework.util.CollectionUtils;


/*** author:
 * description: 覆盖InstanceRegistryBean,设置只允许哪些IP地址注册到Eureka服**务里面来
 * create time: 2020/3/10 16:16
 *
 * @return
 */
public class CustomInstanceRegistry extendsPeerAwareInstanceRegistryImpl
        implementsApplicationContextAware {

    privateApplicationContext ctxt;
    private intdefaultOpenForTrafficCount;

    private List<String>allowedRegisteredIpAddress;

    Logger log = LoggerFactory.getLogger(CustomInstanceRegistry.class);

    publicCustomInstanceRegistry(EurekaServerConfig serverConfig,
                                  EurekaClientConfig clientConfig, ServerCodecs serverCodecs,
                                  EurekaClient eurekaClient, intexpectedNumberOfRenewsPerMin,
                                  intdefaultOpenForTrafficCount,
                                  List<String>allowedRegisteredIpAddress) {
        super(serverConfig, clientConfig, serverCodecs, eurekaClient);

        this.expectedNumberOfRenewsPerMin =expectedNumberOfRenewsPerMin;
        this.defaultOpenForTrafficCount =defaultOpenForTrafficCount;
        this.allowedRegisteredIpAddress =allowedRegisteredIpAddress;
    }

    @Override
    public void setApplicationContext(ApplicationContext context) throwsBeansException {
        this.ctxt =context;
    }

    @Override
    public void openForTraffic(ApplicationInfoManager applicationInfoManager, intcount) {
        super.openForTraffic(applicationInfoManager,
                count == 0 ? this.defaultOpenForTrafficCount : count);

    }

    @Override
    public void register(InstanceInfo info, int leaseDuration, booleanisReplication) {
        handleRegistration(info, leaseDuration, isReplication);
        //不允许注册的IP地址
        if (!CollectionUtils.isEmpty(allowedRegisteredIpAddress) &&
                !allowedRegisteredIpAddress.contains(info.getIPAddr())) {
            log.warn("IP 地址被禁止注册到Eureka实例中:{}", info.getIPAddr());
            return;
        }
        super.register(info, leaseDuration, isReplication);
    }

    @Override
    public void register(final InstanceInfo info, final booleanisReplication) {
        handleRegistration(info, resolveInstanceLeaseDuration(info), isReplication);
        //不允许注册的IP地址
        if (!CollectionUtils.isEmpty(allowedRegisteredIpAddress) &&
                !allowedRegisteredIpAddress.contains(info.getIPAddr())) {
            log.warn("IP 地址被禁止注册到Eureka实例中:{}", info.getIPAddr());
            return;
        }
        super.register(info, isReplication);
    }

    @Override
    public boolean cancel(String appName, String serverId, booleanisReplication) {
        handleCancelation(appName, serverId, isReplication);
        return super.cancel(appName, serverId, isReplication);
    }

    @Override
    public boolean renew(final String appName, finalString serverId,
                         booleanisReplication) {
        log("renew " + appName + " serverId " + serverId + ", isReplication {}"
                +isReplication);
        List<Application> applications =getSortedApplications();
        for(Application input : applications) {
            if(input.getName().equals(appName)) {
                InstanceInfo instance = null;
                for(InstanceInfo info : input.getInstances()) {
                    if(info.getId().equals(serverId)) {
                        instance =info;
                        break;
                    }
                }
                publishEvent(new EurekaInstanceRenewedEvent(this, appName, serverId,
                        instance, isReplication));
                break;
            }
        }
        return super.renew(appName, serverId, isReplication);
    }

    @Override
    protected boolean internalCancel(String appName, String id, booleanisReplication) {
        handleCancelation(appName, id, isReplication);
        return super.internalCancel(appName, id, isReplication);
    }

    private void handleCancelation(String appName, String id, booleanisReplication) {
        log("cancel " + appName + ", serverId " + id + ", isReplication " +isReplication);
        publishEvent(new EurekaInstanceCanceledEvent(this, appName, id, isReplication));
    }

    private void handleRegistration(InstanceInfo info, intleaseDuration,
                                    booleanisReplication) {
        log("register " + info.getAppName() + ", vip " +info.getVIPAddress()
                + ", leaseDuration " + leaseDuration + ", isReplication "
                +isReplication);
        publishEvent(new EurekaInstanceRegisteredEvent(this, info, leaseDuration,
                isReplication));
    }

    private voidlog(String message) {
        if(log.isDebugEnabled()) {
            log.debug(message);
        }
    }

    private voidpublishEvent(ApplicationEvent applicationEvent) {
        this.ctxt.publishEvent(applicationEvent);
    }

    private int resolveInstanceLeaseDuration(finalInstanceInfo info) {
        int leaseDuration =Lease.DEFAULT_DURATION_IN_SECS;
        if (info.getLeaseInfo() != null && info.getLeaseInfo().getDurationInSecs() > 0) {
            leaseDuration =info.getLeaseInfo().getDurationInSecs();
        }
        returnleaseDuration;
    }
}

@Configuration
public classRegisterConfig {
    @Autowired
    privateEurekaServerConfig eurekaServerConfig;
    @Autowired
    privateEurekaClientConfig eurekaClientConfig;
    @Autowired
    @Qualifier(value = "eurekaClient")
    privateEurekaClient eurekaClient;

    @Value("${eureka.server.expectedNumberOfRenewsPerMin:1}")
    private intexpectedNumberOfRenewsPerMin;

    @Value("${eureka.server.defaultOpenForTrafficCount:1}")
    private intdefaultOpenForTrafficCount;

    @Value("${eureka.server.allowed.address:''}")
    privateString[] allowedAddress;

    @Primary
    @Bean(name = "mypeerAwareInstanceRegistry")
    publicPeerAwareInstanceRegistry peerAwareInstanceRegistry(
            ServerCodecs serverCodecs) {
        this.eurekaClient.getApplications();
        return newCustomInstanceRegistry(
                this.eurekaServerConfig,
                this.eurekaClientConfig,
                serverCodecs,
                this.eurekaClient,
                this.expectedNumberOfRenewsPerMin,
                this.defaultOpenForTrafficCount,
                Arrays.asList(allowedAddress)
        );
    }