<dependencies>
<!--boot启动，其实后面有-starter的包，通常spring都写好了一些默认配置-->
   <dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!--web启动，默认用tomcat端口8080，若不导入这个包，将是普通的boot启动，死活启动不了-->
 <dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--thymeleaf包-->
 <dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!--web包-->
 <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.0.5.RELEASE</version>
</dependency>
</dependencies>

########################################################
###THYMELEAF (ThymeleafAutoConfiguration)
########################################################
#spring.thymeleaf.prefix=classpath:/templates/
#spring.thymeleaf.suffix=.html
#spring.thymeleaf.mode=HTML5
#spring.thymeleaf.encoding=UTF-8
## ;charset=<encoding> is added
#spring.thymeleaf.content-type=text/html
#set to false for hot refresh

#理论上已经不需要以上的配置了，只要设置thymeleaf的缓存不保存即可
spring.thymeleaf.cache=false

public class ModuloDataBaseShardingAlgorithm implements SingleKeyDatabaseShardingAlgorithm<Integer> {
    @Override
    public String doEqualSharding(Collection<String> availableTargetNames, ShardingValue<Integer> shardingValue) {
        for (String name : availableTargetNames) {
            /*分成两个库*/
            if (name.endsWith(shardingValue.getValue() % 2 + "")) {
                return name;
            }
        }
        throw new IllegalArgumentException();
    }

    @Override
    public Collection<String> doInSharding(Collection<String> availableTargetNames, ShardingValue<Integer> shardingValue) {
        Collection<String> result = new LinkedHashSet<String>(availableTargetNames.size());
        for (Integer value : shardingValue.getValues()) {
            for (String name : availableTargetNames) {
                if (name.endsWith(value % 2 + "")) {
                    result.add(name);
                }
            }
        }
        return result;
    }

    @Override
    public Collection<String> doBetweenSharding(Collection<String> availableTargetNames, ShardingValue<Integer> shardingValue) {
        Collection<String> result = new LinkedHashSet<String>(availableTargetNames.size());
        Range<Integer> range = (Range<Integer>) shardingValue.getValueRange();
        for (Integer i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
            for (String name : availableTargetNames) {
                if (name.endsWith(i % 2 + "")) {
                    result.add(name);
                }
            }
        }
        return result;
    }
}

public class ShardingJdbc {
    /**
     * main方法
     */
    public static void main(String[] args) {
        Map<String, DataSource> dataSourceMap = new HashMap<String, DataSource>(2);
        dataSourceMap.put("sharding_0", createDataSource("sharding_0"));
        dataSourceMap.put("sharding_1", createDataSource("sharding_1"));

        DataSourceRule dataSourceRule = new DataSourceRule(dataSourceMap);

        //分表分库的表，第一个参数是逻辑表名，第二个是实际表名，第三个是实际库
        TableRule orderTableRule = new TableRule("t_order", Arrays.asList("t_order_0", "t_order_1"), dataSourceRule);
        TableRule orderItemTableRule = new TableRule("t_order_item", Arrays.asList("t_order_item_0", "t_order_item_1"), dataSourceRule);

        /**
         * DatabaseShardingStrategy 分库策略
         * 参数一：根据哪个字段分库
         * 参数二：分库路由函数
         *
         * TableShardingStrategy 分表策略
         * 参数一：根据哪个字段分表
         * 参数二：分表路由函数
         *
         * user_id选择哪个库
         * order_id选择那个表
         *
         * ModuloDataBaseShardingAlgorithm
         * ModuloTableShardingAlgorithm
         * 被2整除是0，反之是1
         *
         */

        ShardingRule shardingRule = new ShardingRule(dataSourceRule, Arrays.asList(orderTableRule, orderItemTableRule)
                , Arrays.asList(new BindingTableRule(Arrays.asList(orderTableRule, orderItemTableRule)))
                , new DatabaseShardingStrategy("user_id", new ModuloDataBaseShardingAlgorithm())
                , new TableShardingStrategy("order_id", new ModuloTableShardingAlgorithm()));

        DataSource dataSource = new ShardingDataSource(shardingRule);
        String sql =
                "SELECT i.* FROM t_order o JOIN t_order_item i " +
                        "ON o.order_id=i.order_id " +
                        "WHERE o.user_id= ? AND o.order_id = ?";
        try {
            Connection connection = dataSource.getConnection();
            PreparedStatement preparedStatement = connection.prepareStatement(sql);

//            preparedStatement.setInt(1, 10);
//            preparedStatement.setInt(2, 1001);

//             先根据分库规则去了sharding_1
//             o.user_id=11
            preparedStatement.setInt(1, 11);
//            再根据分表规则去了t_order_0,t_order_item_0
//            o.order_id=1000
            preparedStatement.setInt(2, 1000);

            ResultSet result = preparedStatement.executeQuery();
            while (result.next()) {
                System.out.println("1--------" + result.getInt(1));
                System.out.println("2--------" + result.getInt(2));
                System.out.println("3--------" + result.getInt(3));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * @param dataSourceName
     * @return dataSource
     * @DESCRIPTION 创建数据源
     */
    private static DataSource createDataSource(String dataSourceName) {
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl(String.format("jdbc:mysql://localhost:3306/%s", dataSourceName));
        dataSource.setUsername("root");
        dataSource.setPassword("123456789");
        return dataSource;
    }
}

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lgp</groupId>
    <artifactId>mybatis-generator</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>mybatis-generator</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.0</version>
        </dependency>
    </dependencies>

    <build>
        <!--&lt;!&ndash;把xml放入编译环境内 eclipse配置&ndash;&gt;-->
        <!--<resources>-->
        <!--<resource>-->
        <!--<directory>src/main/java</directory>-->
        <!--<includes>-->
        <!--<include>**/*.xml</include>-->
        <!--</includes>-->
        <!--<filtering>true</filtering>-->
        <!--</resource>-->
        <!--</resources>-->
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.2</version>
                <!--配置要用的驱动-->
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>5.1.44</version>
                    </dependency>
                </dependencies>
                <configuration>
                    <!--配置文件的路径-->
                    <configurationFile>src/main/resources/generatorConfig.xml</configurationFile>
                    <overwrite>true</overwrite>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>

package com.lgp.wechatshare.handle;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.lgp.wechatshare.constant.WeiXinInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

import java.util.HashMap;
import java.util.Map;

/**
 * @AUTHOR lgp
 * @DATE 2018/4/16 21:27
 * @DESCRIPTION
 **/
@Component
public class WeiXinHandler {
    private static Logger logger = LoggerFactory.getLogger(WeiXinHandler.class);

    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private WeiXinInfo weiXinInfo;

    /**
     * 生成用于获取access_token的Code的Url
     *
     * @param redirectUrl
     * @return
     */
    public String getRequestCodeUrl(String redirectUrl, String scope) {
        return String.format("https://open.weixin.qq.com/connect/oauth2/authorize?appid=%s&redirect_uri=%s&response_type=code&scope=%s&state=%s#wechat_redirect",
                weiXinInfo.getAppID(), redirectUrl, scope, "code");
    }

    /**
     * 获取请求用户信息的access_token
     *
     * @param code
     * @return { "
     * access_token":"ACCESS_TOKEN",
     * "expires_in":7200,
     * "refresh_token":"REFRESH_TOKEN",
     * "openid":"OPENID",
     * "scope":"SCOPE"
     * }
     */
    public Map<String, String> getWeiXinAccessInfo(String code) throws Exception {
        String url = String.format("https://api.weixin.qq.com/sns/oauth2/access_token?appid=%s&secret=%s&code=%s&grant_type=authorization_code",
                weiXinInfo.getAppID(), weiXinInfo.getAppSecret(), code);
        logger.info("WeiXinClient.getWeiXinAccessInfo.url: {}", url);
        try {
            String result = restTemplate.getForObject(url, String.class);
            logger.info("WeiXinClient.getWeiXinAccessInfo.result: {}", result);
            ObjectMapper mapper = new ObjectMapper();
            return mapper.readValue(result, Map.class);
        } catch (NullPointerException e) {
            throw new NullPointerException("code 已被使用" + code);
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }

    public String getWeiXinOpenId(String code) throws Exception {
        Map<String, String> data = getWeiXinAccessInfo(code);
        return data.get("openid");
    }

    public String getAccessToken(String code) throws Exception {
        Map<String, String> data = getWeiXinAccessInfo(code);
        return data.get("access_token");
    }

    /**
     * 获取用户信息
     * grantType 默认为refresh_token
     * {
     * "access_token":"ACCESS_TOKEN",
     * "expires_in":7200,
     * "refresh_token":"REFRESH_TOKEN",
     * "openid":"OPENID",
     * "scope":"SCOPE"
     * }
     * 返回的新token于旧token不同
     */
    public Map<String, String> refreshAcessToken(String accessToken, String openId, String grantType) throws Exception {
        String url = "ttps://api.weixin.qq.com/sns/oauth2/refresh_token?appid==" + openId + "&grant_type=" + grantType + "&refresh_token=" + accessToken;
        logger.info("WeiXinClient.refreshAcessToken.url: {}", url);
        try {
            String result = restTemplate.getForObject(url, String.class);
            logger.info("WeiXinClient.refreshAcessToken.result: {}", result);
            ObjectMapper mapper = new ObjectMapper();
            return mapper.readValue(result, Map.class);
        } catch (NullPointerException e) {
            throw new NullPointerException("accessToken和openId已经过期");
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }

    /**
     * 获取用户信息
     * {
     * "openid":" OPENID",
     * " nickname": NICKNAME,
     * "sex":"1",
     * "province":"PROVINCE"
     * "city":"CITY",
     * "country":"COUNTRY",
     * "headimgurl":    "http://thirdwx.qlogo.cn/mmopen/g3MonUZtNHkdmzicIlibx6iaFqAc56vxLSUfpb6n5WKSYVY0ChQKkiaJSgQ1dZuTOgvLLrhJbERQQ4eMsv84eavHiaiceqxibJxCfHe/46",
     * "privilege":[ "PRIVILEGE1" "PRIVILEGE2"     ],
     * "unionid": "o6_bmasdasdsad6_2sgVt7hMZOPfL"
     * }
     */
    public Map<String, String> getUserInfo(String accessToken, String openId) throws Exception {
        String url = "https://api.weixin.qq.com/sns/userinfo?access_token=" + accessToken + "&openid=" + openId + "&;
        logger.info("WeiXinClient.getUserInfo.url: {}", url);
        try {
            String result = restTemplate.getForObject(url, String.class);
            logger.info("WeiXinClient.getUserInfo.result: {}", result);
            ObjectMapper mapper = new ObjectMapper();
            return mapper.readValue(result, Map.class);
        } catch (NullPointerException e) {
            throw new NullPointerException("accessToken和openId已经过期");
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }

    /**
     * 检验授权凭证
     */
    public Boolean auth(String accessToken, String openId) throws Exception {
        Map<String, String> data = new HashMap();
        String url = "https://api.weixin.qq.com/sns/auth?access_token=" + accessToken + "&openid=" + openId;
        logger.info("WeiXinClient.auth.url: {}", url);
        try {
            String result = restTemplate.getForObject(url, String.class);
            logger.info("WeiXinClient.auth.result: {}", result);
            ObjectMapper mapper = new ObjectMapper();
            data = mapper.readValue(result, Map.class);
            if ("ok".equals(data.get("errmsg"))) {
                return true;
            }
            return false;
        } catch (NullPointerException e) {
            throw new NullPointerException("accessToken和openId已经过期");
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }
}

@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    /**
     * 1.首先当我们要自定义Spring Security的时候我们需要继承自WebSecurityConfigurerAdapter来完成，相关配置重写对应 方法即可。
     * 2.我们在这里注册CustomUserService的Bean，然后通过重写configure方法添加我们自定义的认证方式。
     */
    @Bean
    UserDetailsService customUserService() {
        return new CustomUserService();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder authenticationManagerBuilder) throws Exception {
        authenticationManagerBuilder.userDetailsService(customUserService());
    }

    /**
     * 3.在configure(HttpSecurity http)方法中，我们设置了登录页面，而且登录页面任何人都可以访问，然后设置了登录失败地址，也设置了注销请求，注销请求也是任何人都可以访问的。
     * 4.permitAll表示该请求任何人都可以访问，.anyRequest().authenticated(),表示其他的请求都必须要有权限认证。
     * 5.这里我们可以通过匹配器来匹配路径，比如antMatchers方法，假设我要管理员才可以访问admin文件夹下的内容，我可以这样来写：.
     *          antMatchers("/admin/**").hasRole("ROLE_ADMIN")，也
     * 可以设置admin文件夹下的文件可以有多个角色来访问，写法如下：
     *         antMatchers("/admin/**").hasAnyRole("ROLE_ADMIN","ROLE_USER")
     * 6.可以通过hasIpAddress来指定某一个ip可以访问该资源,假设只允许访问ip为210.210.210.210的请求获取admin下的资源，写法如下.
     *          antMatchers("/admin/**").hasIpAddress("210.210.210.210")
     */
    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        httpSecurity.authorizeRequests()
//                留意代码顺序
//                首页（不需要登陆就能访问的页面
                .antMatchers("/index").permitAll()
                .anyRequest().authenticated()
//                需要登陆才能访问的页面
                .and().formLogin().loginPage("/login").defaultSuccessUrl("/index").failureUrl("/login?error").permitAll()
                .and().logout().logoutUrl("/logout").logoutSuccessUrl("/login").permitAll()
                .and().rememberMe().tokenValiditySeconds(60 * 60 * 24 * 7).key("kkkkkkkk");
    }
}

    <div class="starter-template">
        <h1 th:text="${msg.title}"></h1>
        <p class="bg-primary" th:text="${msg.content}"></p>
        <div sec:authorize="hasRole('ROLE_ADMIN')">
            <p class="bg-info" th:text="${msg.extraInfo}"></p>
        </div>
        <div sec:authorize="hasRole('ROLE_USER')">
            <p class="bg-info">无更多显示信息</p>
        </div>
        <form th:action="@{/logout}" method="post">
            <input type="submit" class="btn btn-primary" value="注销"/>
        </form>
    </div>

@Entity
public class One {

    @Id
    @GeneratedValue
    private Long id;
    private Long name;

//    @OneToOne(cascade = CascadeType.ALL)
//    private Two two;

//    @OneToMany
//    private Set<Two> two;

//    @ManyToMany
//    private Set<Two> two;
}

@Entity
public class Two {

    @Id
    @GeneratedValue
    private Long id;

    private Long name;

    @ManyToOne
    private One one;
}

/**
 * Created by IntelliJ IDEA.
 * User: a247292980
 * Date: 2017/08/14
 * <p>
 * 处理WebJars，无视版本号，使用带版本号的方法可注释此类
 **/
@Controller
public class WebJarController {
    private final WebJarAssetLocator assetLocator = new WebJarAssetLocator();

    /**
     * RequestMapping的地址是固定的
     */
    @ResponseBody
    @RequestMapping("/webjarslocator/{webjar}/**")
    public ResponseEntity locateWebjarAsset(@PathVariable String webjar, HttpServletRequest request) {
        try {
            String mvcPrefix = "/webjarslocator/" + webjar + "/";
            String mvcPath = (String) request.getAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE);
            String fullPath = assetLocator.getFullPath(webjar, mvcPath.substring(mvcPrefix.length()));
            return new ResponseEntity(new ClassPathResource(fullPath), HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity(HttpStatus.NOT_FOUND);
        }
    }

}

<head>
    <!--<script src="/webjars/jquery/3.1.1/jquery.min.js"></script>-->
    <script src="/webjars/jquery/jquery.min.js"></script>
    <!--<script src="/webjars/bootstrap/3.3.7-1/js/bootstrap.min.js"></script>-->
    <script src="/webjars/bootstrap/js/bootstrap.min.js"></script>
    <title>demo.html Demo</title>
    <!--<link rel="stylesheet" href="/webjars/bootstrap/3.3.7-1/css/bootstrap.min.css" target="_blank" rel="external nofollow"  />-->
    <link rel="stylesheet" href="/webjars/bootstrap/css/bootstrap.min.css" target="_blank" rel="external nofollow"  />
</head>

package com.lgp.aop.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * @AUTHOR lgp
 * @DATE 2018/8/3 17:12
 * @DESCRIPTION
 **/
@Aspect
@Component
public class AnnotationAspect {
    protected org.slf4j.Logger logger = LoggerFactory.getLogger(this.getClass());

    /**
     * @Aspect 作用是把当前类标识为一个切面供容器读取
     * @Before 标识一个前置增强方法，相当于BeforeAdvice的功能
     * @AfterReturning 后置增强，相当于AfterReturningAdvice，方法退出时执行
     * @AfterThrowing 异常抛出增强，相当于ThrowsAdvice
     * @After final增强，不管是抛出异常或者正常退出都会执行
     * @Around 环绕增强，相当于MethodInterceptor
     *
     * 除了@Around外，每个方法里都可以加或者不加参数JoinPoint，
     * 如果有用JoinPoint的地方就加，不加也可以，JoinPoint里包含了类名、被切面的方法名，参数等属性，可供读取使用。
     * @Around参数必须为ProceedingJoinPoint pjp.proceed相应于执行被切面的方法。
     * @AfterReturning方法里， 可以加returning = “XXX”，XXX即为在controller里方法的返回值。
     * @AfterThrowing方法里， 可以加throwing = "XXX"，供读取异常信息，throwing = "ex"
     */


    @Pointcut(value = "@annotation(com.lgp.aop.aop.Log)")
    public void log() {
    }

    @Before("log()")
    public void deBefore(JoinPoint joinPoint) throws Throwable {
        System.out.println("annotation before");
    }

    @Around("@annotation(log)")
    public Object around(ProceedingJoinPoint pjp, Log log) {
        //获取注解里的值
        System.out.println("annotation around:" + log.description());
        try {
            return pjp.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            return null;
        }
    }
}

package com.lgp.aop.aop;


import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;

/**
 * Created by IntelliJ IDEA.
 * User: a247292980
 * Date: 2017/08/14
 * <p>
 * 方法的aop
 */
@Aspect
@Component
public class FunctionAspect {
    protected org.slf4j.Logger logger = LoggerFactory.getLogger(FunctionAspect.class);

    /**
     * execution函数
     * 用于匹配方法执行的连接点，语法为：execution(方法修饰符(可选)  返回类型  方法名  参数  异常模式(可选))
     * 参数部分允许使用通配符：
     * *  匹配任意字符，但只能匹配一个元素
     * .. 匹配任意字符，可以匹配任意多个元素，表示类时，必须和*联合使用
     * +  必须跟在类名后面，如Horseman+，表示类本身和继承或扩展指定类的所有类
     * 除了execution()，Spring中还支持其他多个函数，这里列出名称和简单介绍，以方便根据需要进行更详细的查询
     * @annotation() 表示标注了指定注解的目标类方法
     * 例如 @annotation(org.springframework.transaction.annotation.Transactional) 表示标注了@Transactional的方法
     * args()通过目标类方法的参数类型指定切点 例如 args(String) 表示有且仅有一个String型参数的方法
     * @args() 通过目标类参数的对象类型是否标注了指定注解指定切点 如 @args(org.springframework.stereotype.Service) 表示有且仅有一个标注了@Service的类参数的方法
     * within()通过类名指定切点 如 with(examples.chap03.Horseman) 表示Horseman的所有方法
     * @within() 匹配标注了指定注解的类及其所有子类 如 @within(org.springframework.stereotype.Service) 给Horseman加上@Service标注，则Horseman和Elephantman 的所有方法都匹配
     * target()通过类名指定，同时包含所有子类 如 target(examples.chap03.Horseman)  且Elephantman extends Horseman，则两个类的所有方法都匹配
     * @target() 所有标注了指定注解的类 如 @target(org.springframework.stereotype.Service) 表示所有标注了@Service的类的所有方法
     * this() 大部分时候和target()相同，区别是this是在运行时生成代理类后，才判断代理类与指定的对象类型是否匹配
     * */


    /**
     * 定义有一个切入点，范围为service包下的类
     */
    @Pointcut("execution(public * com.lgp.aop.service.*.*(..))")
    public void service() {
    }

    @Around("service()")
    public void doAround(JoinPoint joinPoint) throws Throwable {
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        // 记录下请求内容
        System.out.println("URL : " + request.getRequestURL().toString());
        System.out.println("HTTP_METHOD : " + request.getMethod());
        System.out.println("IP : " + request.getRemoteAddr());
        System.out.println("CLASS_METHOD : " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
        System.out.println("ARGS : " + Arrays.toString(joinPoint.getArgs()));
    }

}