refactor directory tree

spring-cloud-alibaba-sentinel/pom.xml

@@ -0,0 +1,87 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+    <parent>
+        <groupId>org.springframework.cloud</groupId>
+        <artifactId>spring-cloud-alibaba</artifactId>
+        <version>0.1.0.BUILD-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.springframework.cloud</groupId>
+    <artifactId>spring-cloud-alibaba-sentinel</artifactId>
+    <name>Spring Cloud Alibaba Sentinel Autoconfigure</name>
+
+    <dependencies>
+
+        <dependency>
+            <groupId>com.alibaba.csp</groupId>
+            <artifactId>sentinel-web-servlet</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.alibaba.csp</groupId>
+            <artifactId>sentinel-transport-simple-http</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.alibaba.csp</groupId>
+            <artifactId>sentinel-annotation-aspectj</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.alibaba.csp</groupId>
+            <artifactId>sentinel-dubbo-adapter</artifactId>
+        </dependency>
+
+        <!--spring boot-->
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-aop</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-actuator</artifactId>
+            <scope>provided</scope>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-configuration-processor</artifactId>
+            <scope>provided</scope>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot</artifactId>
+            <scope>provided</scope>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-autoconfigure</artifactId>
+            <scope>provided</scope>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+            <scope>provided</scope>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+    </dependencies>
+
+</project>

spring-cloud-alibaba-sentinel/src/main/java/org/springframework/cloud/alibaba/sentinel/SentinelProperties.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.alibaba.sentinel;
+
+import java.util.List;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.boot.context.properties.NestedConfigurationProperty;
+import org.springframework.core.Ordered;
+
+/**
+ * @author xiaojing
+ * @author hengyunabc
+ */
+@ConfigurationProperties(prefix = "spring.cloud.sentinel")
+public class SentinelProperties {
+
+	/**
+	 * Enable sentinel auto configure, the default value is true
+	 */
+	private boolean enabled = true;
+
+	/**
+	 * sentinel api port,default value is 8721
+	 */
+	private String port = "8721";
+
+	/**
+	 * Sentinel dashboard address, won't try to connect dashboard when address is empty
+	 */
+	private String dashboard = "";
+
+	@NestedConfigurationProperty
+	private Filter filter;
+
+	public boolean isEnabled() {
+		return enabled;
+	}
+
+	public void setEnabled(boolean enabled) {
+		this.enabled = enabled;
+	}
+
+	public String getPort() {
+		return port;
+	}
+
+	public void setPort(String port) {
+		this.port = port;
+	}
+
+	public String getDashboard() {
+		return dashboard;
+	}
+
+	public void setDashboard(String dashboard) {
+		this.dashboard = dashboard;
+	}
+
+	public Filter getFilter() {
+		return filter;
+	}
+
+	public void setFilter(Filter filter) {
+		this.filter = filter;
+	}
+
+	public static class Filter {
+
+		/**
+		 * Sentinel filter chain order.
+		 */
+		private int order = Ordered.HIGHEST_PRECEDENCE;
+
+		/**
+		 * URL pattern for sentinel filter,default is /*
+		 */
+		private List<String> urlPatterns;
+
+		public int getOrder() {
+			return this.order;
+		}
+
+		public void setOrder(int order) {
+			this.order = order;
+		}
+
+		public List<String> getUrlPatterns() {
+			return urlPatterns;
+		}
+
+		public void setUrlPatterns(List<String> urlPatterns) {
+			this.urlPatterns = urlPatterns;
+		}
+	}
+}

spring-cloud-alibaba-sentinel/src/main/java/org/springframework/cloud/alibaba/sentinel/SentinelWebAutoConfiguration.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.alibaba.sentinel;
+
+import com.alibaba.csp.sentinel.adapter.servlet.CommonFilter;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.alibaba.csp.sentinel.transport.config.TransportConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.boot.web.servlet.FilterRegistrationBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.util.StringUtils;
+
+import javax.annotation.PostConstruct;
+import javax.servlet.Filter;
+
+/**
+ * @author xiaojing
+ */
+@Configuration
+@ConditionalOnWebApplication
+@ConditionalOnProperty(name = "spring.cloud.sentinel.enabled", matchIfMissing = true)
+@EnableConfigurationProperties(SentinelProperties.class)
+public class SentinelWebAutoConfiguration {
+	private static final Logger logger = LoggerFactory
+			.getLogger(SentinelWebAutoConfiguration.class);
+
+	@Value("${project.name:${spring.application.name:}}")
+	private String projectName;
+
+	@Autowired
+	private SentinelProperties properties;
+
+	public static final String APP_NAME = "project.name";
+
+	@PostConstruct
+	private void init() {
+		if (StringUtils.isEmpty(System.getProperty(APP_NAME))) {
+			System.setProperty(APP_NAME, projectName);
+		}
+		if (StringUtils.isEmpty(System.getProperty(TransportConfig.SERVER_PORT))) {
+			System.setProperty(TransportConfig.SERVER_PORT, properties.getPort());
+		}
+		if (StringUtils.isEmpty(System.getProperty(TransportConfig.CONSOLE_SERVER))) {
+			System.setProperty(TransportConfig.CONSOLE_SERVER, properties.getDashboard());
+		}
+
+	}
+
+	@Bean
+	@ConditionalOnWebApplication
+	public FilterRegistrationBean servletRequestListener() {
+		FilterRegistrationBean registration = new FilterRegistrationBean();
+
+		SentinelProperties.Filter filterConfig = properties.getFilter();
+
+		if (null == filterConfig) {
+			filterConfig = new SentinelProperties.Filter();
+			properties.setFilter(filterConfig);
+		}
+
+		if (filterConfig.getUrlPatterns() == null
+				|| filterConfig.getUrlPatterns().isEmpty()) {
+			List<String> defaultPatterns = new ArrayList<>();
+			defaultPatterns.add("/*");
+			filterConfig.setUrlPatterns(defaultPatterns);
+		}
+
+		registration.addUrlPatterns(filterConfig.getUrlPatterns().toArray(new String[0]));
+		Filter filter = new CommonFilter();
+		registration.setFilter(filter);
+		registration.setOrder(filterConfig.getOrder());
+		logger.info("[Sentinel Starter] register Sentinel with urlPatterns: {}.",
+				filterConfig.getUrlPatterns());
+		return registration;
+
+	}
+}

spring-cloud-alibaba-sentinel/src/main/java/org/springframework/cloud/alibaba/sentinel/annotation/SentinelProtect.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.alibaba.sentinel.annotation;
+
+import org.springframework.beans.factory.annotation.Qualifier;
+
+import java.lang.annotation.*;
+
+/**
+ * @author fangjian
+ */
+@Target({ ElementType.METHOD, ElementType.FIELD })
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Qualifier
+public @interface SentinelProtect {
+
+    String blockHandler() default "";
+
+    Class<?> blockHandlerClass() default void.class;
+
+    String fallback() default "";
+
+    Class<?> fallbackClass() default void.class;
+
+}

spring-cloud-alibaba-sentinel/src/main/java/org/springframework/cloud/alibaba/sentinel/custom/BlockClassRegistry.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.alibaba.sentinel.custom;
+
+import java.lang.reflect.Method;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.alibaba.csp.sentinel.util.StringUtil;
+
+/**
+ * @author fangjian
+ */
+final class BlockClassRegistry {
+
+    private static final Map<String, Method> FALLBACK_MAP = new ConcurrentHashMap<>();
+    private static final Map<String, Method> BLOCK_HANDLER_MAP = new ConcurrentHashMap<>();
+
+    static Method lookupFallback(Class<?> clazz, String name) {
+        return FALLBACK_MAP.get(getKey(clazz, name));
+    }
+
+    static Method lookupBlockHandler(Class<?> clazz, String name) {
+        return BLOCK_HANDLER_MAP.get(getKey(clazz, name));
+    }
+
+    static void updateFallbackFor(Class<?> clazz, String name, Method method) {
+        if (clazz == null || StringUtil.isBlank(name)) {
+            throw new IllegalArgumentException("Bad argument");
+        }
+        FALLBACK_MAP.put(getKey(clazz, name), method);
+    }
+
+    static void updateBlockHandlerFor(Class<?> clazz, String name, Method method) {
+        if (clazz == null || StringUtil.isBlank(name)) {
+            throw new IllegalArgumentException("Bad argument");
+        }
+        BLOCK_HANDLER_MAP.put(getKey(clazz, name), method);
+    }
+
+    private static String getKey(Class<?> clazz, String name) {
+        return String.format("%s:%s", clazz.getCanonicalName(), name);
+    }
+
+}

spring-cloud-alibaba-sentinel/src/main/java/org/springframework/cloud/alibaba/sentinel/custom/SentinelAutoConfiguration.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.alibaba.sentinel.custom;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.client.RestTemplate;
+
+import com.alibaba.csp.sentinel.annotation.aspectj.SentinelResourceAspect;
+
+/**
+ * @author xiaojing
+ */
+@Configuration
+public class SentinelAutoConfiguration {
+
+    @Bean
+    @ConditionalOnMissingBean
+    public SentinelResourceAspect sentinelResourceAspect() {
+        return new SentinelResourceAspect();
+    }
+
+    @Bean
+    @ConditionalOnMissingBean
+    @ConditionalOnClass(value = RestTemplate.class)
+    public SentinelBeanPostProcessor sentinelBeanPostProcessor() {
+        return new SentinelBeanPostProcessor();
+    }
+
+}

spring-cloud-alibaba-sentinel/src/main/java/org/springframework/cloud/alibaba/sentinel/custom/SentinelBeanPostProcessor.java

@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.alibaba.sentinel.custom;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.DefaultListableBeanFactory;
+import org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor;
+import org.springframework.beans.factory.support.RootBeanDefinition;
+import org.springframework.cloud.alibaba.sentinel.annotation.SentinelProtect;
+import org.springframework.context.ApplicationContext;
+import org.springframework.core.type.StandardMethodMetadata;
+import org.springframework.util.StringUtils;
+import org.springframework.web.client.RestTemplate;
+
+/**
+ * PostProcessor handle @SentinelProtect Annotation, add interceptor for RestTemplate
+ *
+ * @author fangjian
+ * @see SentinelProtect
+ * @see SentinelProtectInterceptor
+ */
+public class SentinelBeanPostProcessor implements MergedBeanDefinitionPostProcessor {
+
+    @Autowired
+    private ApplicationContext applicationContext;
+
+    private ConcurrentHashMap<String, SentinelProtect> cache = new ConcurrentHashMap<>();
+
+    @Override
+    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition,
+                                                Class<?> beanType, String beanName) {
+        if (checkSentinelProtect(beanDefinition, beanType)) {
+            SentinelProtect sentinelProtect = ((StandardMethodMetadata) beanDefinition
+                    .getSource()).getIntrospectedMethod()
+                    .getAnnotation(SentinelProtect.class);
+            cache.put(beanName, sentinelProtect);
+        }
+    }
+
+    private boolean checkSentinelProtect(RootBeanDefinition beanDefinition,
+                                         Class<?> beanType) {
+        return beanType == RestTemplate.class
+                && beanDefinition.getSource() instanceof StandardMethodMetadata
+                && ((StandardMethodMetadata) beanDefinition.getSource())
+                .isAnnotated(SentinelProtect.class.getName());
+    }
+
+    @Override
+    public Object postProcessAfterInitialization(Object bean, String beanName)
+            throws BeansException {
+        if (cache.containsKey(beanName)) {
+            // add interceptor for each RestTemplate with @SentinelProtect annotation
+            StringBuilder interceptorBeanName = new StringBuilder();
+            SentinelProtect sentinelProtect = cache.get(beanName);
+            interceptorBeanName
+                    .append(StringUtils.uncapitalize(
+                            SentinelProtectInterceptor.class.getSimpleName()))
+                    .append("_")
+                    .append(sentinelProtect.blockHandlerClass().getSimpleName())
+                    .append(sentinelProtect.blockHandler()).append("_")
+                    .append(sentinelProtect.fallbackClass().getSimpleName())
+                    .append(sentinelProtect.fallback());
+            RestTemplate restTemplate = (RestTemplate) bean;
+            registerBean(interceptorBeanName.toString(), sentinelProtect);
+            SentinelProtectInterceptor sentinelProtectInterceptor = applicationContext
+                    .getBean(interceptorBeanName.toString(),
+                            SentinelProtectInterceptor.class);
+            restTemplate.getInterceptors().add(sentinelProtectInterceptor);
+        }
+        return bean;
+    }
+
+    private void registerBean(String interceptorBeanName,
+                              SentinelProtect sentinelProtect) {
+        // register SentinelProtectInterceptor bean
+        DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) applicationContext
+                .getAutowireCapableBeanFactory();
+        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder
+                .genericBeanDefinition(SentinelProtectInterceptor.class);
+        beanDefinitionBuilder.addConstructorArgValue(sentinelProtect);
+        BeanDefinition interceptorBeanDefinition = beanDefinitionBuilder
+                .getRawBeanDefinition();
+        beanFactory.registerBeanDefinition(interceptorBeanName,
+                interceptorBeanDefinition);
+    }
+
+    @Override
+    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
+        return bean;
+    }
+
+}

spring-cloud-alibaba-sentinel/src/main/java/org/springframework/cloud/alibaba/sentinel/custom/SentinelEntry.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.alibaba.sentinel.custom;
+
+import com.alibaba.csp.sentinel.Entry;
+
+/**
+ * @author xiaojing
+ */
+public class SentinelEntry {
+
+	private String key;
+	private String handler;
+
+	private Entry entry;
+
+	public String getKey() {
+		return key;
+	}
+
+	public void setKey(String key) {
+		this.key = key;
+	}
+
+	public String getHandler() {
+		return handler;
+	}
+
+	public void setHandler(String handler) {
+		this.handler = handler;
+	}
+
+	public Entry getEntry() {
+		return entry;
+	}
+
+	public void setEntry(Entry entry) {
+		this.entry = entry;
+	}
+}

spring-cloud-alibaba-sentinel/src/main/java/org/springframework/cloud/alibaba/sentinel/custom/SentinelProtectInterceptor.java

@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.alibaba.sentinel.custom;
+
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.net.URI;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.cloud.alibaba.sentinel.annotation.SentinelProtect;
+import org.springframework.http.HttpRequest;
+import org.springframework.http.client.ClientHttpRequestExecution;
+import org.springframework.http.client.ClientHttpRequestInterceptor;
+import org.springframework.http.client.ClientHttpResponse;
+import org.springframework.util.ClassUtils;
+
+import com.alibaba.csp.sentinel.Entry;
+import com.alibaba.csp.sentinel.SphU;
+import com.alibaba.csp.sentinel.context.ContextUtil;
+import com.alibaba.csp.sentinel.slots.block.BlockException;
+import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
+import com.alibaba.csp.sentinel.util.StringUtil;
+
+/**
+ * Interceptor using by SentinelProtect and SentinelProtectInterceptor
+ *
+ * @author fangjian
+ */
+public class SentinelProtectInterceptor implements ClientHttpRequestInterceptor {
+
+    private static final Logger LOGGER = LoggerFactory
+            .getLogger(SentinelProtectInterceptor.class);
+
+    private SentinelProtect sentinelProtect;
+
+    public SentinelProtectInterceptor(SentinelProtect sentinelProtect) {
+        this.sentinelProtect = sentinelProtect;
+    }
+
+    @Override
+    public ClientHttpResponse intercept(HttpRequest request, byte[] body,
+                                        ClientHttpRequestExecution execution) throws IOException {
+        URI uri = request.getURI();
+        String hostResource = uri.getScheme() + "://" + uri.getHost() + ":"
+                + (uri.getPort() == -1 ? 80 : uri.getPort());
+        String hostWithPathResource = hostResource + uri.getPath();
+        Entry hostEntry = null, hostWithPathEntry = null;
+        ClientHttpResponse response = null;
+        try {
+            ContextUtil.enter(hostWithPathResource);
+            hostWithPathEntry = SphU.entry(hostWithPathResource);
+            hostEntry = SphU.entry(hostResource);
+            response = execution.execute(request, body);
+        }
+        catch (BlockException e) {
+            LOGGER.error("RestTemplate block", e);
+            try {
+                handleBlockException(e);
+            }
+            catch (Exception ex) {
+                LOGGER.error("sentinel handle BlockException error.", e);
+            }
+        }
+        finally {
+            if (hostEntry != null) {
+                hostEntry.exit();
+            }
+            if (hostWithPathEntry != null) {
+                hostWithPathEntry.exit();
+            }
+            ContextUtil.exit();
+        }
+        return response;
+    }
+
+    private void handleBlockException(BlockException ex) throws Exception {
+        Object[] args = new Object[] { ex };
+        // handle degrade
+        if (isDegradeFailure(ex)) {
+            Method method = extractFallbackMethod(sentinelProtect.fallback(),
+                    sentinelProtect.fallbackClass());
+            if (method != null) {
+                method.invoke(null, args);
+            }
+        }
+        // handle block
+        Method blockHandler = extractBlockHandlerMethod(sentinelProtect.blockHandler(),
+                sentinelProtect.blockHandlerClass());
+        if (blockHandler != null) {
+            blockHandler.invoke(null, args);
+        }
+    }
+
+    private Method extractFallbackMethod(String fallback, Class<?> fallbackClass) {
+        if (StringUtil.isBlank(fallback) || fallbackClass == void.class) {
+            return null;
+        }
+        Method cachedMethod = BlockClassRegistry.lookupFallback(fallbackClass, fallback);
+        if (cachedMethod == null) {
+            cachedMethod = ClassUtils.getStaticMethod(fallbackClass, fallback,
+                    BlockException.class);
+            BlockClassRegistry.updateFallbackFor(fallbackClass, fallback, cachedMethod);
+        }
+        return cachedMethod;
+    }
+
+    private Method extractBlockHandlerMethod(String block, Class<?> blockClass) {
+        if (StringUtil.isBlank(block) || blockClass == void.class) {
+            return null;
+        }
+        Method cachedMethod = BlockClassRegistry.lookupBlockHandler(blockClass, block);
+        if (cachedMethod == null) {
+            cachedMethod = ClassUtils.getStaticMethod(blockClass, block,
+                    BlockException.class);
+            BlockClassRegistry.updateBlockHandlerFor(blockClass, block, cachedMethod);
+        }
+        return cachedMethod;
+    }
+
+    private boolean isDegradeFailure(BlockException ex) {
+        return ex instanceof DegradeException;
+    }
+
+}

spring-cloud-alibaba-sentinel/src/main/java/org/springframework/cloud/alibaba/sentinel/endpoint/SentinelEndpoint.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.alibaba.sentinel.endpoint;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
+import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
+import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
+import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
+import com.alibaba.csp.sentinel.slots.system.SystemRule;
+import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.actuate.endpoint.AbstractEndpoint;
+import org.springframework.cloud.alibaba.sentinel.SentinelProperties;
+
+/**
+ * Endpoint for Sentinel, contains ans properties and rules
+ * @author xiaojing
+ */
+public class SentinelEndpoint extends AbstractEndpoint<Map<String, Object>> {
+
+	@Autowired
+	private SentinelProperties sentinelProperties;
+
+	public SentinelEndpoint() {
+		super("sentinel");
+	}
+
+	@Override
+	public Map<String, Object> invoke() {
+		Map<String, Object> result = new HashMap<>();
+
+		List<FlowRule> flowRules = FlowRuleManager.getRules();
+		List<DegradeRule> degradeRules = DegradeRuleManager.getRules();
+		List<SystemRule> systemRules = SystemRuleManager.getRules();
+		result.put("properties", sentinelProperties);
+		result.put("FlowRules", flowRules);
+		result.put("DegradeRules", degradeRules);
+		result.put("SystemRules", systemRules);
+		return result;
+	}
+
+}

spring-cloud-alibaba-sentinel/src/main/java/org/springframework/cloud/alibaba/sentinel/endpoint/SentinelEndpointAutoConfiguration.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.alibaba.sentinel.endpoint;
+
+import org.springframework.boot.actuate.condition.ConditionalOnEnabledEndpoint;
+import org.springframework.boot.actuate.endpoint.Endpoint;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.cloud.alibaba.sentinel.SentinelProperties;
+import org.springframework.context.annotation.Bean;
+
+/**
+ * @author hengyunabc
+ */
+@ConditionalOnClass(Endpoint.class)
+@EnableConfigurationProperties({ SentinelProperties.class })
+public class SentinelEndpointAutoConfiguration {
+
+	@Bean
+	@ConditionalOnMissingBean
+	@ConditionalOnEnabledEndpoint("sentinel")
+	public SentinelEndpoint sentinelEndPoint() {
+		return new SentinelEndpoint();
+	}
+
+}

spring-cloud-alibaba-sentinel/src/main/resources/META-INF/additional-spring-configuration-metadata.json

@@ -0,0 +1,32 @@
+{
+  "properties": [
+    {
+      "name": "spring.cloud.sentinel.enabled",
+      "type": "java.lang.Boolean",
+      "defaultValue": true,
+      "description": "enable or disable sentinel auto configure."
+    },
+    {
+      "name": "spring.cloud.sentinel.port",
+      "type": "java.lang.String",
+      "defaultValue": "8721",
+      "description": "sentinel api port."
+    },
+    {
+      "name": "spring.cloud.sentinel.dashboard",
+      "type": "java.lang.String",
+      "description": "sentinel dashboard address, won't try to connect dashboard when address is empty."
+    },
+    {
+      "name": "spring.cloud.sentinel.filter.order",
+      "type": "java.lang.Integer",
+      "defaultValue": "Integer.MIN_VALUE",
+      "description": "Sentinel filter chain order, will be set to FilterRegistrationBean."
+    },
+    {
+      "name": "spring.cloud.sentinel.filter.urlPatterns",
+      "type": "java.util.List",
+      "description": "URL pattern for Sentinel filter, default contains '/*'."
+    }
+  ]
+}

spring-cloud-alibaba-sentinel/src/main/resources/META-INF/spring.factories

@@ -0,0 +1,4 @@
+org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
+org.springframework.cloud.alibaba.sentinel.SentinelWebAutoConfiguration,\
+org.springframework.cloud.alibaba.sentinel.endpoint.SentinelEndpointAutoConfiguration,\
+org.springframework.cloud.alibaba.sentinel.custom.SentinelAutoConfiguration

spring-cloud-alibaba-sentinel/src/test/java/org/springframework/cloud/alibaba/sentinel/SentinelAutoConfigurationTests.java

@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.alibaba.sentinel;
+
+import com.alibaba.csp.sentinel.slots.block.BlockException;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.boot.test.util.EnvironmentTestUtils;
+import org.springframework.boot.web.servlet.FilterRegistrationBean;
+import org.springframework.cloud.alibaba.sentinel.annotation.SentinelProtect;
+import org.springframework.cloud.alibaba.sentinel.custom.SentinelAutoConfiguration;
+import org.springframework.cloud.alibaba.sentinel.custom.SentinelBeanPostProcessor;
+import org.springframework.cloud.alibaba.sentinel.custom.SentinelProtectInterceptor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+/**
+ * @author fangjian
+ */
+public class SentinelAutoConfigurationTests {
+
+    private final AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
+
+    @Before
+    public void init() {
+        context.register(SentinelAutoConfiguration.class, SentinelWebAutoConfiguration.class, SentinelTestConfiguration.class);
+        EnvironmentTestUtils.addEnvironment(this.context,
+            "spring.cloud.sentinel.port=8888",
+            "spring.cloud.sentinel.filter.order=123",
+            "spring.cloud.sentinel.filter.urlPatterns=/*,/test");
+        this.context.refresh();
+    }
+
+    @After
+    public void closeContext() {
+        this.context.close();
+    }
+
+    @Test
+    public void testFilter() {
+        assertThat(context.getBean(
+            "servletRequestListener").getClass() == FilterRegistrationBean.class).isTrue();
+    }
+
+    @Test
+    public void testBeanPostProcessor() {
+        assertThat(context.getBean("sentinelBeanPostProcessor")
+                .getClass() == SentinelBeanPostProcessor.class).isTrue();
+    }
+
+    @Test
+    public void testProperties() {
+        SentinelProperties sentinelProperties = context.getBean(SentinelProperties.class);
+        assertThat(sentinelProperties).isNotNull();
+        assertThat(sentinelProperties.getPort()).isEqualTo("8888");
+        assertThat(sentinelProperties.getFilter().getUrlPatterns().size()).isEqualTo(2);
+        assertThat(sentinelProperties.getFilter().getUrlPatterns().get(0)).isEqualTo("/*");
+        assertThat(sentinelProperties.getFilter().getUrlPatterns().get(1)).isEqualTo("/test");
+    }
+
+    @Test
+    public void testRestTemplate() {
+        assertThat(context.getBeansOfType(RestTemplate.class).size()).isEqualTo(2);
+        RestTemplate restTemplate = context.getBean("restTemplateWithBlockClass",
+                RestTemplate.class);
+        assertThat(restTemplate.getInterceptors().size()).isEqualTo(1);
+        assertThat(restTemplate.getInterceptors().get(0).getClass())
+                .isEqualTo(SentinelProtectInterceptor.class);
+    }
+
+    @Configuration
+    static class SentinelTestConfiguration {
+
+        @Bean
+        @SentinelProtect
+        RestTemplate restTemplate() {
+            return new RestTemplate();
+        }
+
+        @Bean
+        @SentinelProtect(blockHandlerClass = ExceptionUtil.class, blockHandler = "handleException")
+        RestTemplate restTemplateWithBlockClass() {
+            return new RestTemplate();
+        }
+
+    }
+
+    static class ExceptionUtil {
+        public static void handleException(BlockException ex) {
+            System.out.println("Oops: " + ex.getClass().getCanonicalName());
+        }
+    }
+
+
+}