Spring-Boot整合微信登陆、微信支付、邮箱发送、支付宝支付和阿里云短信

标签：return String 微信支付 private Spring import com public

Spring-Boot整合

1. 发送邮件
2. 支付宝支付
3. 阿里云短信
4. 微信登陆
5. 微信支付
6. Swargger2 前后端API接口信息文档
7. ehcache缓存缓存
8. Spring-Boot注解详解
9. 自定义配置文件类

1. 发送邮件

添加依赖

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

创建 mail.properties 配置文件

mail.host=smtp.qq.com
#邮箱地址
mail.username=*****@qq.com
#邮箱授权码
mail.password=********
#是否启用加密
mail.smtpAuth=true
#
mail.smtpStarttlsEnable=true
mail.smtpStarttlsRequired=true
mail.defaultEncoding=UTF-8

创建配置类

package com.example.demo1.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

/**
 * 邮箱类
 */
@Component
//配置属性文件
@PropertySource("classpath:mail.properties")
//说明配置文件属性的头部
@ConfigurationProperties(prefix = "mail")
public class MailConfig {
    private String host;
    private String username;
    private String password;
    private String smtpAuth;
    private String smtpStarttlsEnable;
    private String smtpStarttlsRequired;
    private String defaultEncoding;

   //getter and setter 
}

创建工具类

package com.example.demo1.utils;

import com.example.demo1.config.MailConfig;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSenderImpl;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Properties;

@Component
public class MailUtils {
    @Resource
    private MailConfig mailConfig;

    /**
     * 邮箱发送方法
     *
     * @param to      收信人
     * @param title   邮箱标题
     * @param content 邮箱内容
     */
    public boolean sendMail(String to, String title, String content) {
        try {
            //邮箱消息对象
            SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
            simpleMailMessage.setFrom(mailConfig.getUsername());//发送人
            simpleMailMessage.setTo(to);//收件人
            simpleMailMessage.setSubject(title);//邮箱标题
            simpleMailMessage.setText(content);//邮箱内容

            //邮箱发送对象
            JavaMailSenderImpl javaMailSender = new JavaMailSenderImpl();
            javaMailSender.setUsername(mailConfig.getUsername());
            javaMailSender.setHost(mailConfig.getHost());
            javaMailSender.setPassword(mailConfig.getPassword());
            javaMailSender.setDefaultEncoding(mailConfig.getDefaultEncoding());

            Properties properties = new Properties();
            properties.setProperty("mail.smtp.auth", mailConfig.getSmtpAuth());
            properties.setProperty("mail.smtp.starttls.enable", mailConfig.getSmtpStarttlsEnable());
            properties.setProperty("mail.smtp.starttls.required", mailConfig.getSmtpStarttlsRequired());
            javaMailSender.setJavaMailProperties(properties);

            //实现发送邮箱
            javaMailSender.send(simpleMailMessage);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}

创建 MailController

package com.example.demo1.controller;

import com.alibaba.fastjson.JSONObject;
import com.example.demo1.pojo.Test;
import com.example.demo1.service.TestService;
import com.example.demo1.utils.MailUtils;
import com.example.demo1.utils.RandomUtils;
import com.example.demo1.utils.RedisUtils;
import com.example.demo1.utils.TokenUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Api(tags = "邮箱登陆")
@RestController
@RequestMapping("test")
public class MailController {
    @Resource
    private MailUtils mailUtils;
    @Resource
    private RedisUtils redisUtils;
    @Resource
    private TestService testService;
    @Resource
    private TokenUtils tokenUtils;

    /* 发送验证码 */
    @ApiOperation("发送验证码")
    @GetMapping("/sendmail")
    public Object sendMail(@ApiParam(value = "请求头", required = true) HttpServletRequest request) {
        Map<String, Object> dto = new HashMap<>();
        String to = request.getHeader("to");
        //判断是否已经发送过验证码
        String code = redisUtils.get(to);
        if (code != null) {
            dto.put("msg", "验证码10分钟内有效");
            dto.put("code", 6000);
            return dto;
        }

        //生产随机数
        Integer ran = RandomUtils.genNumByLen(6);
        String title = "登陆";
        String content = "验证码" + ran + "，5分钟内有效";
        //发送验证码
        if (mailUtils.sendMail(to, title, content)) {
            // 把验证码保存到redis中
            redisUtils.set(to, ran.toString(), 300, TimeUnit.SECONDS);
            dto.put("msg", "发送成功");
            dto.put("code", 2);
            return dto;
        }
        dto.put("msg", "发送失败");
        dto.put("code", -2);
        return dto;
    }

    /* 邮箱登陆 */
    @ApiOperation("邮箱登陆")
    @GetMapping("/maillogin")
    public Object mailLogin(HttpServletRequest request) {
        String to = request.getHeader("to");
        String code = request.getHeader("code");
        Map<String, Object> dto = new HashMap<>();
        //从redis中获取验证吗
        String rCode = redisUtils.get(to);

        if (!rCode.equals(code)) {
            dto.put("msg", "验证码错误");
            dto.put("code", 0);
            return dto;
        }

        //判断用户是否存在
        Test test = testService.getUserByEmail(to);
        if (test == null) {//新用户
            test = new Test();
            test.setCode(to);
            //添加用户到数据库
            /* ---------------------      添加并获取id      ------------- */
            if (!testService.addUser(test)) {
                dto.put("msg", "登陆失败");
                dto.put("code", -1);
                return dto;
            }
        }

        //生成token
        String token = tokenUtils.getToken("Mail-", test.getId(), RandomUtils.genNumByLen(6));
        //把token存入redis中 30分钟有效
        redisUtils.set(token, JSONObject.toJSONString(test), 30 * 60, TimeUnit.SECONDS);
        dto.put("msg", "登陆成功");
        dto.put("code", 1);
        dto.put("token", token);
        return dto;
    }

    /**
     * 用于测试token的替换
     *
     * @param request 请求对象
     * @return
     */
    @ApiOperation("用于测试token的替换")
    @GetMapping("getUser")
    public Object getUser(@ApiParam(value = "请求对象") HttpServletRequest request) {
        Map<String, Object> dto = new HashMap<>();
        String token = request.getHeader("token");
        //判断token存在
        if (!redisUtils.hasKey(token)) {
            dto.put("msg", "token失效");
            dto.put("code", -3);
            return dto;
        }
        //把redis转换成对象
        Test test = JSONObject.parseObject(redisUtils.get(token), Test.class);
        token = tokenUtils.replaceToken(token, "Mail-", test);
        dto.put("msg", "token有效");
        dto.put("code", 3);
        dto.put("token", token);
        return dto;
    }
}

2. 支付宝支付

引入依赖

<!-- 支付宝支付 -->
<dependency>
    <groupId>com.alipay.sdk</groupId>
    <artifactId>alipay-easysdk</artifactId>
    <version>2.0.1</version>
</dependency>

创建 AliPayConfig 配置类

package com.example.demo1.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Component
@PropertySource("classpath:alipay.properties")
@ConfigurationProperties("alipay")
public class AliPayConfig {
    private String protocol;
    private String gatewayHost;
    private String signType;
    private String appId;
    private String merchantPrivateKey;
    private String notifyUrl;
    private String returnUrl;
    private String encryptKey;
    private String alipayPublicKey;
    private String successUrl;

    // getter and setter
}

创建 AliPayUtils 工具类

package com.example.demo1.utils;

import com.alipay.easysdk.factory.Factory;
import com.alipay.easysdk.factory.Factory.Payment;
import com.alipay.easysdk.kernel.Config;
import com.alipay.easysdk.kernel.util.ResponseChecker;
import com.alipay.easysdk.payment.page.models.AlipayTradePagePayResponse;
import com.example.demo1.config.AliPayConfig;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Map;

/**
 * 阿里支付工具类
 */
@Component
public class AliPayUtils {
    @Resource
    private AliPayConfig aliPayConfig;

    public AliPayConfig getAliPayConfig() {
        return aliPayConfig;
    }

    /**
     * 支付
     *
     * @param sunject 项目名称
     * @param payNo   订单号
     * @param amount  支付金额
     * @return
     */
    public String toPcPay(String sunject, String payNo, String amount) {
        String result = "";
        // 1. 设置参数（全局只需设置一次）
        Factory.setOptions(getOptions());
        try {
            // 2. 发起API调用
            AlipayTradePagePayResponse response = Payment.Page().pay(sunject, payNo, amount, aliPayConfig.getReturnUrl());
            // 3. 处理响应或异常
            if (ResponseChecker.success(response)) {
                result = response.body;
                System.out.println("调用成功");
            } else {
                System.err.println("调用失败，原因：" + response.body);
            }
        } catch (Exception e) {
            System.err.println("调用遭遇异常，原因：" + e.getMessage());
            throw new RuntimeException(e.getMessage(), e);
        }
        return result;
    }

    private Config getOptions() {
        Config config = new Config();
        config.protocol = aliPayConfig.getProtocol();
        config.gatewayHost = aliPayConfig.getGatewayHost();
        config.signType = aliPayConfig.getSignType();
        config.appId = aliPayConfig.getAppId();
        config.merchantPrivateKey = aliPayConfig.getMerchantPrivateKey();
        config.encryptKey = aliPayConfig.getEncryptKey();
        config.notifyUrl = aliPayConfig.getNotifyUrl();
        config.alipayPublicKey = aliPayConfig.getAlipayPublicKey();
        return config;
    }

    /**
     * 验签
     *
     * @param parameters
     * @return
     * @throws Exception
     */
    public Boolean verify(Map<String, String> parameters) throws Exception {
        return Factory.Payment.Common().verifyNotify(parameters);
    }
}

新增测试页面

<!DOCTYPE html>
<html>

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>支付测试页</title>
</head>

<body>
    <form action="/test/alipay" method="POST">
        <label for="subject">项目名:</label>
        <input type="text" name="subject">
        <br>
        <label for="payno">订单号：</label>
        <input type="text" name="payno">
        <br>
        <label for="amount">订单金额：</label>
        <input type="text" name="amount">
        <br>
        <input type="submit" value="支付">
    </form>
</body>

</html>

3. 阿里云短信

引入依赖

<!-- 发送短信 -->
<dependency>
    <groupId>com.aliyun</groupId>
    <artifactId>aliyun-java-sdk-core</artifactId>
    <version>4.5.3</version>
</dependency>

2.创建ssm.properties配置文件

#此处替填写'AccessKey ID'
sms.accessKeyId=**************
#此处填写'AccessKey Secret'
sms.secret=**************
# 最近服务器地点
sms.RegionId=cn-hangzhou
sms.domain=dysmsapi.aliyuncs.com
sms.version=2017-05-25
sms.action=SendSms
#此处替换为'签名名称'
sms.signName=**
#此处替换为'模版CODE'
sms.templateCode=***

创建配置类

package com.example.demo1.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Component
@PropertySource("classpath:ssm.properties")
@ConfigurationProperties(prefix = "sms")
public class AliyunSSMConfig {
    private String accessKeyId;
    private String secret;
    private String RegionId;
    private String domain;
    private String version;
    private String action;
    private String signName;
    private String templateCode;
    //getter and setter
}

创建工具类

package com.example.demo1.utils;

import com.alibaba.fastjson.JSONObject;
import com.aliyuncs.CommonRequest;
import com.aliyuncs.CommonResponse;
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.exceptions.ServerException;
import com.aliyuncs.http.MethodType;
import com.aliyuncs.profile.DefaultProfile;
import com.example.demo1.config.AliyunSSMConfig;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Component
public class AliyunSMSUtils {

    @Resource
    private AliyunSSMConfig aliyunSSMConfig;

    /**
     * 发送短信
     *
     * @param phone 手机号
     * @param code  验证码
     */
    public boolean sendMessage(String phone, String code) {
        DefaultProfile profile = DefaultProfile.getProfile(aliyunSSMConfig.getRegionId(),
                aliyunSSMConfig.getAccessKeyId(), aliyunSSMConfig.getSecret());
        //客服端对象
        IAcsClient client = new DefaultAcsClient(profile);
        //请求对象
        CommonRequest request = new CommonRequest();
        //请求方式
        request.setSysMethod(MethodType.POST);
        request.setSysDomain(aliyunSSMConfig.getDomain());
        request.setSysVersion(aliyunSSMConfig.getVersion());
        //具体操作
        request.setSysAction(aliyunSSMConfig.getAction());
        request.putQueryParameter("RegionId", aliyunSSMConfig.getRegionId());
        request.putQueryParameter("PhoneNumbers", phone);
        request.putQueryParameter("SignName", aliyunSSMConfig.getSignName());
        request.putQueryParameter("TemplateCode", aliyunSSMConfig.getTemplateCode());
        // 参数  和模板里的格式一样
        request.putQueryParameter("TemplateParam", "{\"code\":\"" + code + "\"}");

        try {
            //响应对象
            CommonResponse response = client.getCommonResponse(request);
            System.out.println(response.getData());
            // 获取状态码  （固定）
            String status = JSONObject.parseObject(response.getData()).get("Code").toString();
            return "OK".equals(status);
        } catch (ServerException e) {
            e.printStackTrace();
        } catch (ClientException e) {
            e.printStackTrace();
        }
        return false;
    }
}

创建 AliyunController

package com.example.demo1.controller;

import com.alibaba.fastjson.JSONObject;
import com.example.demo1.pojo.Test;
import com.example.demo1.service.TestService;
import com.example.demo1.utils.MailUtils;
import com.example.demo1.utils.RandomUtils;
import com.example.demo1.utils.RedisUtils;
import com.example.demo1.utils.TokenUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Api(tags = "邮箱登陆")
@RestController
@RequestMapping("test")
public class MailController {
    @Resource
    private MailUtils mailUtils;
    @Resource
    private RedisUtils redisUtils;
    @Resource
    private TestService testService;
    @Resource
    private TokenUtils tokenUtils;

    /* 发送验证码 */
    @ApiOperation("发送验证码")
    @GetMapping("/sendmail")
    public Object sendMail(@ApiParam(value = "请求头", required = true) HttpServletRequest request) {
        Map<String, Object> dto = new HashMap<>();
        String to = request.getHeader("to");
        //判断是否已经发送过验证码
        String code = redisUtils.get(to);
        if (code != null) {
            dto.put("msg", "验证码10分钟内有效");
            dto.put("code", 6000);
            return dto;
        }

        //生产随机数
        Integer ran = RandomUtils.genNumByLen(6);
        String title = "登陆";
        String content = "验证码" + ran + "，5分钟内有效";
        //发送验证码
        if (mailUtils.sendMail(to, title, content)) {
            // 把验证码保存到redis中
            redisUtils.set(to, ran.toString(), 300, TimeUnit.SECONDS);
            dto.put("msg", "发送成功");
            dto.put("code", 2);
            return dto;
        }
        dto.put("msg", "发送失败");
        dto.put("code", -2);
        return dto;
    }

    /* 邮箱登陆 */
    @ApiOperation("邮箱登陆")
    @GetMapping("/maillogin")
    public Object mailLogin(HttpServletRequest request) {
        String to = request.getHeader("to");
        String code = request.getHeader("code");
        Map<String, Object> dto = new HashMap<>();
        //从redis中获取验证吗
        String rCode = redisUtils.get(to);

        if (!rCode.equals(code)) {
            dto.put("msg", "验证码错误");
            dto.put("code", 0);
            return dto;
        }

        //判断用户是否存在
        Test test = testService.getUserByEmail(to);
        if (test == null) {//新用户
            test = new Test();
            test.setCode(to);
            //添加用户到数据库
            /* ---------------------      添加并获取id      ------------- */
            if (!testService.addUser(test)) {
                dto.put("msg", "登陆失败");
                dto.put("code", -1);
                return dto;
            }
        }

        //生成token
        String token = tokenUtils.getToken("Mail-", test.getId(), RandomUtils.genNumByLen(6));
        //把token存入redis中 30分钟有效
        redisUtils.set(token, JSONObject.toJSONString(test), 30 * 60, TimeUnit.SECONDS);
        dto.put("msg", "登陆成功");
        dto.put("code", 1);
        dto.put("token", token);
        return dto;
    }

    /**
     * 用于测试token的替换
     *
     * @param request 请求对象
     * @return
     */
    @ApiOperation("用于测试token的替换")
    @GetMapping("getUser")
    public Object getUser(@ApiParam(value = "请求对象") HttpServletRequest request) {
        Map<String, Object> dto = new HashMap<>();
        String token = request.getHeader("token");
        //判断token存在
        if (!redisUtils.hasKey(token)) {
            dto.put("msg", "token失效");
            dto.put("code", -3);
            return dto;
        }
        //把redis转换成对象
        Test test = JSONObject.parseObject(redisUtils.get(token), Test.class);
        token = tokenUtils.replaceToken(token, "Mail-", test);
        dto.put("msg", "token有效");
        dto.put("code", 3);
        dto.put("token", token);
        return dto;
    }
}

4. 微信登陆

引入依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.31</version>
</dependency>

创建 wxlogin.properties 配置文件

wxlogin.openUrl=https://open.weixin.qq.com/connect/qrconnect
wxlogin.appid=*********
# 回调地址 接收用户信息的Url
wxlogin.redirectUri=http://localhost:8080/test/wechat/callback
wxlogin.responseType=code
wxlogin.scope=snsapi_login
wxlogin.state=STATE#wechat_redirect
# 再去微信服务器拿token的url
wxlogin.accessTokenUrl=https://api.weixin.qq.com/sns/oauth2/access_token
wxlogin.secret=********
wxlogin.grantType=authorization_code
# 获取微信用户的信息
wxlogin.userInfoUrl=https://api.weixin.qq.com/sns/userinfo

创建 WxLoginConfig 配置类

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

/**
 * 微信登陆配置文件类
 */
@Component
@ConfigurationProperties(prefix = "wxlogin")
@PropertySource("classpath:wxlogin.properties")
public class WxLoginConfig {
    private String appid;
    private String redirectUri;
    private String responseType;
    private String scope;
    private String state;
    private String openUrl;
    private String accessTokenUrl;
    private String secret;
    private String grantType;
    private String userInfoUrl;

    //getter and serter
}

创建 UrlUtils 工具类

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * 微信登陆Url工具类
 */
public class UrlUtils {

    /**
     * 获取url网址返回的数据内容
     *
     * @param urlStr
     * @return
     */
    public static String loadURL(String urlStr) {
        try {
            URL url = new URL(urlStr);
            //连接网址对象
            HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
            // 连接方式
            urlConnection.setRequestMethod("GET");
            urlConnection.connect();
            //获取返回的输入流
            InputStream inputStream = urlConnection.getInputStream();
            //把输入流转换成字符串
            String responseStr = ConvertToString(inputStream);
            return responseStr;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     *  输入流转换成字符串
     * @param inputStream
     * @return
     */
    private static String ConvertToString(InputStream inputStream) {
        InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        StringBuilder result = new StringBuilder();
        String line = null;
        try {
            while ((line = bufferedReader.readLine()) != null) {
                result.append(line + "\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                inputStreamReader.close();
                inputStream.close();
                bufferedReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result.toString();
    }
}

创建 WxLoginController API接口

import com.alibaba.fastjson.JSONObject;
import com.example.demo1.config.WxLoginConfig;
import com.example.demo1.utils.RandomUtils;
import com.example.demo1.utils.RedisUtils;
import com.example.demo1.utils.TokenUtils;
import com.example.demo1.utils.UrlUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/test")
public class WxLoginController {
    @Resource
    private WxLoginConfig wxLoginConfig;
    @Resource
    private RedisUtils redisUtils;
    @Resource
    private TokenUtils tokenUtils;

    /**
     * 显示微信登陆扫码界面
     *
     * @param response
     * @throws Exception
     */
    @RequestMapping("/wechat/login")
    public void wechat(HttpServletResponse response) throws Exception {
        // 构建获取二维码的URL
        StringBuffer wxsb = new StringBuffer(wxLoginConfig.getOpenUrl());
        wxsb.append("?appid=" + wxLoginConfig.getAppid());
        wxsb.append("&redirect_uri=" + wxLoginConfig.getRedirectUri());
        wxsb.append("&response_type=" + wxLoginConfig.getResponseType());
        wxsb.append("&scope=" + wxLoginConfig.getScope());
        wxsb.append("&state=" + wxLoginConfig.getState());
        response.sendRedirect(wxsb.toString());
    }

    /**
     * 用户手机确认后回调函数
     *
     * @param code
     * @throws Exception
     */
    @RequestMapping("/wechat/callback")
    public Object callback(String code) throws Exception {
        Map<String, Object> dto = new HashMap<>();
        // 构造请求URL
        StringBuffer wxsb = new StringBuffer(wxLoginConfig.getAccessTokenUrl());
        wxsb.append("?appid=" + wxLoginConfig.getAppid());
        wxsb.append("&secret=" + wxLoginConfig.getSecret());
        wxsb.append("&code=" + code);
        wxsb.append("&grant_type=" + wxLoginConfig.getGrantType());
        // 发送请求并获取accessToken和opendId
        String resp = UrlUtils.loadURL(wxsb.toString());
        JSONObject jsonObject = JSONObject.parseObject(resp);
        String accessToken = jsonObject.getString("access_token");
        String openId = jsonObject.getString("openid");
        // 构造获取用户信息的URL
        StringBuffer usb = new StringBuffer(wxLoginConfig.getUserInfoUrl());
        usb.append("?access_token=" + accessToken);
        usb.append("&openid=" + openId);
        // 发送请求并获取用户信息
        String userInfo = UrlUtils.loadURL(usb.toString());
        JSONObject userObject = JSONObject.parseObject(userInfo);
        if (userObject == null) {
            dto.put("msg", "微信登陆失败");
            dto.put("code", -4);
            return dto;
        }
        //生产token
        String token = tokenUtils.getToken("WX-", 1, RandomUtils.genNumByLen(6));
        redisUtils.set(token, JSONObject.toJSONString(userObject), 30 * 60, TimeUnit.SECONDS);
        dto.put("msg", "微信登陆成功");
        dto.put("code", 4);
        dto.put("token", token);
        return dto;
    }
}

5. 微信支付

添加依赖

<dependency>
  <groupId>com.github.wxpay</groupId>
  <artifactId>wxpay-sdk</artifactId>
  <version>0.0.3</version>
</dependency>

微信app支付参数配置

#服务器域名地址
server.service-domain = http://127.0.0.1:8080

#微信app支付
pay.wxpay.app.appID = "你的appid"
pay.wxpay.app.mchID = "你的商户id"
pay.wxpay.app.key = "你的api秘钥，不是appSecret"
#从微信商户平台下载的安全证书存放的路径、我放在resources下面,切记一定要看看target目录下的class文件下有没有打包apiclient_cert.p12文件
pay.wxpay.app.certPath = static/cert/wxpay/apiclient_cert.p12
#微信支付成功的异步通知接口
pay.wxpay.app.payNotifyUrl=${server.service-domain}/api/wxPay/notify

创建配置类

import com.github.wxpay.sdk.WXPayConfig;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.io.InputStream;

/**
 * 配置我们自己的信息
 */
@Component
@ConfigurationProperties(prefix = "pay.wxpay.app")
public class WxPayAppConfig implements WXPayConfig {
    /**
     * appID
     */
    private String appID;

    /**
     * 商户号
     */
    private String mchID;

    /**
     * API 密钥
     */
    private String key;

    /**
     * API证书绝对路径 (本项目放在了 resources/cert/wxpay/apiclient_cert.p12")
     */
    private String certPath;

    /**
     * HTTP(S) 连接超时时间，单位毫秒
     */
    private int httpConnectTimeoutMs = 8000;

    /**
     * HTTP(S) 读数据超时时间，单位毫秒
     */
    private int httpReadTimeoutMs = 10000;

    /**
     * 微信支付异步通知地址
     */
    private String payNotifyUrl;

    /**
     * 微信退款异步通知地址
     */
    private String refundNotifyUrl;

    /**
     * 获取商户证书内容（这里证书需要到微信商户平台进行下载）
     *
     * @return 商户证书内容
     */
    @Override
    public InputStream getCertStream() {
        InputStream certStream  =getClass().getClassLoader().getResourceAsStream(certPath);
        return certStream;
    }

    public String getAppID() {
        return appID;
    }

    public void setAppID(String appID) {
        this.appID = appID;
    }

    public String getMchID() {
        return mchID;
    }

    public void setMchID(String mchID) {
        this.mchID = mchID;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getCertPath() {
        return certPath;
    }

    public void setCertPath(String certPath) {
        this.certPath = certPath;
    }

    public int getHttpConnectTimeoutMs() {
        return httpConnectTimeoutMs;
    }

    public void setHttpConnectTimeoutMs(int httpConnectTimeoutMs) {
        this.httpConnectTimeoutMs = httpConnectTimeoutMs;
    }

    public int getHttpReadTimeoutMs() {
        return httpReadTimeoutMs;
    }

    public void setHttpReadTimeoutMs(int httpReadTimeoutMs) {
        this.httpReadTimeoutMs = httpReadTimeoutMs;
    }

    public String getPayNotifyUrl() {
        return payNotifyUrl;
    }

    public void setPayNotifyUrl(String payNotifyUrl) {
        this.payNotifyUrl = payNotifyUrl;
    }

    public String getRefundNotifyUrl() {
        return refundNotifyUrl;
    }

    public void setRefundNotifyUrl(String refundNotifyUrl) {
        this.refundNotifyUrl = refundNotifyUrl;
    }
}

定义controller

在调用微信服务接口进行统一下单之前，
1、为保证安全性，建议验证数据库是否存在订单号对应的订单。

package com.annaru.upms.payment.controller;

import com.annaru.common.result.ResultMap;
import com.annaru.upms.payment.service.WxPayService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

@Api(tags = "微信支付接口管理")
@RestController
@RequestMapping("/wxPay")
public class WxPayController{

    @Autowired
    private WxPayService wxPayService;

    /**
     * 统一下单接口
     */
    @ApiOperation(value = "统一下单", notes = "统一下单")
    @GetMapping("/unifiedOrder")
    public ResultMap unifiedOrder(
        @ApiParam(value = "订单号") @RequestParam String orderNo,
        @ApiParam(value = "订单金额") @RequestParam double amount,
        @ApiParam(value = "商品名称") @RequestParam String body,
                                  HttpServletRequest request) {
        try {
            // 1、验证订单是否存在
            
            // 2、开始微信支付统一下单
            ResultMap resultMap = wxPayService.unifiedOrder(orderNo, orderNo, body);
            return resultMap;//系统通用的返回结果集，见文章末尾
        } catch (Exception e) {
            logger.error(e.getMessage());
            return ResultMap.error("运行异常，请联系管理员");
        }
    }
    
    /**
     * 微信支付异步通知
     */
    @RequestMapping(value = "/notify")
    public String payNotify(HttpServletRequest request) {
        InputStream is = null;
        String xmlBack = "<xml><return_code><![CDATA[FAIL]]></return_code><return_msg><![CDATA[报文为空]]></return_msg></xml> ";
        try {
            is = request.getInputStream();
            // 将InputStream转换成String
            BufferedReader reader = new BufferedReader(new InputStreamReader(is));
            StringBuilder sb = new StringBuilder();
            String line = null;
            while ((line = reader.readLine()) != null) {
                sb.append(line + "\n");
            }
            xmlBack = wxPayService.notify(sb.toString());
        } catch (Exception e) {
            logger.error("微信手机支付回调通知失败：", e);
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return xmlBack;
    }
    
    @ApiOperation(value = "退款", notes = "退款")
    @PostMapping("/refund")
    public ResultMap refund(@ApiParam(value = "订单号") @RequestParam String orderNo,
                            @ApiParam(value = "退款金额") @RequestParam double amount,
                            @ApiParam(value = "退款原因") @RequestParam(required = false) String refundReason){

        return wxPayService.refund(orderNo, amount, refundReason);
    }

}

定义service接口

package com.annaru.upms.payment.service;

import com.annaru.common.result.ResultMap;

/**
 * 微信支付服务接口
 */
public interface WxPayService {

    /**
     * @Description: 微信支付统一下单
     * @param orderNo: 订单编号
     * @param amount: 实际支付金额
     * @param body: 订单描述
     * @Author: 
     * @Date: 2019/8/1
     * @return
     */
    ResultMap unifiedOrder(String orderNo, double amount, String body) ;

    /**
     * @Description: 订单支付异步通知
     * @param notifyStr: 微信异步通知消息字符串
     * @Author: 
     * @Date: 2019/8/1
     * @return 
     */
    String notify(String notifyStr) throws Exception;
    
    /**
     * @Description: 退款
     * @param orderNo: 订单编号
     * @param amount: 实际支付金额
     * @param refundReason: 退款原因
     * @Author: XCK
     * @Date: 2019/8/6
     * @return
     */
    ResultMap refund(String orderNo, double amount, String refundReason);
}

service实现类

package com.annaru.upms.payment.service.impl;

import com.alibaba.dubbo.config.annotation.Reference;
import com.annaru.common.result.ResultMap;
import com.annaru.common.util.HttpContextUtils;
import com.annaru.upms.payment.config.WxPayAppConfig;
import com.annaru.upms.payment.service.WxPayService;
import com.annaru.upms.service.IOrderPaymentService;
import com.github.wxpay.sdk.WXPay;
import com.github.wxpay.sdk.WXPayUtil;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class WxPayServiceImpl implements WxPayService {
    private final Logger logger = LoggerFactory.getLogger(WxPayServiceImpl.class);

    @Reference
    private IOrderPaymentService orderPaymentService;
    @Autowired
    private WxPayAppConfig wxPayAppConfig;

    @Override
    public ResultMap unifiedOrder(String orderNo, double amount, String body) {
        Map<String, String> returnMap = new HashMap<>();
        Map<String, String> responseMap = new HashMap<>();
        Map<String, String> requestMap = new HashMap<>();
        try {
            WXPay wxpay = new WXPay(wxPayAppConfig);
            requestMap.put("body", body);                                     // 商品描述
            requestMap.put("out_trade_no", orderNo);                          // 商户订单号
            requestMap.put("total_fee", String.valueOf((int)(amount*100)));   // 总金额
            requestMap.put("spbill_create_ip", HttpContextUtils.getIpAddr()); // 终端IP
            requestMap.put("trade_type", "APP");                              // App支付类型
            requestMap.put("notify_url", wxPayAppConfig.getPayNotifyUrl());   // 接收微信支付异步通知回调地址
            Map<String, String> resultMap = wxpay.unifiedOrder(requestMap);
            //获取返回码
            String returnCode = resultMap.get("return_code");
            String returnMsg = resultMap.get("return_msg");
            //若返回码为SUCCESS，则会返回一个result_code,再对该result_code进行判断
            if ("SUCCESS".equals(returnCode)) {
                String resultCode = resultMap.get("result_code");
                String errCodeDes = resultMap.get("err_code_des");
                if ("SUCCESS".equals(resultCode)) {
                    responseMap = resultMap;
                }
            }
            if (responseMap == null || responseMap.isEmpty()) {
                return ResultMap.error("获取预支付交易会话标识失败");
            }
            // 3、签名生成算法
            Long time = System.currentTimeMillis() / 1000;
            String timestamp = time.toString();
            returnMap.put("appid", wxPayAppConfig.getAppID());
            returnMap.put("partnerid", wxPayAppConfig.getMchID());
            returnMap.put("prepayid", responseMap.get("prepay_id"));
            returnMap.put("noncestr", responseMap.get("nonce_str"));
            returnMap.put("timestamp", timestamp);
            returnMap.put("package", "Sign=WXPay");
            returnMap.put("sign", WXPayUtil.generateSignature(returnMap, wxPayAppConfig.getKey()));//微信支付签名
            return ResultMap.ok().put("data", returnMap);
        } catch (Exception e) {
            logger.error("订单号：{}，错误信息：{}", orderNo, e.getMessage());
            return ResultMap.error("微信支付统一下单失败");
        }
    }

    @Override
    public String notify(String notifyStr) {
        String xmlBack = "<xml><return_code><![CDATA[FAIL]]></return_code><return_msg><![CDATA[报文为空]]></return_msg></xml> ";
        try {
            // 转换成map
            Map<String, String> resultMap = WXPayUtil.xmlToMap(notifyStr);
            WXPay wxpayApp = new WXPay(wxPayAppConfig);
            if (wxpayApp.isPayResultNotifySignatureValid(resultMap)) {
                String returnCode = resultMap.get("return_code");  //状态
                String outTradeNo = resultMap.get("out_trade_no");//商户订单号
                String transactionId = resultMap.get("transaction_id");
                if (returnCode.equals("SUCCESS")) {
                    if (StringUtils.isNotBlank(outTradeNo)) {
                        /**
                         * 注意！！！
                         * 请根据业务流程，修改数据库订单支付状态，和其他数据的相应状态
                         *
                         */
                        logger.info("微信手机支付回调成功,订单号:{}", outTradeNo);
                        xmlBack = "<xml><return_code><![CDATA[SUCCESS]]></return_code><return_msg><![CDATA[OK]]></return_msg></xml>";
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return xmlBack;
    }
    
     @Override
    public ResultMap refund(String orderNo, double amount, String refundReason){

        if(StringUtils.isBlank(orderNo)){
            return ResultMap.error("订单编号不能为空");
        }
        if(amount <= 0){
            return ResultMap.error("退款金额必须大于0");
        }

        Map<String, String> responseMap = new HashMap<>();
        Map<String, String> requestMap = new HashMap<>();
        WXPay wxpay = new WXPay(wxPayAppConfig);
        requestMap.put("out_trade_no", orderNo);
        requestMap.put("out_refund_no", UUIDGenerator.getOrderNo());
        requestMap.put("total_fee", "订单支付时的总金额，需要从数据库查");
        requestMap.put("refund_fee", String.valueOf((int)(amount*100)));//所需退款金额
        requestMap.put("refund_desc", refundReason);
        try {
            responseMap = wxpay.refund(requestMap);
        } catch (Exception e) {
            e.printStackTrace();
        }
        String return_code = responseMap.get("return_code");   //返回状态码
        String return_msg = responseMap.get("return_msg");     //返回信息
        if ("SUCCESS".equals(return_code)) {
            String result_code = responseMap.get("result_code");       //业务结果
            String err_code_des = responseMap.get("err_code_des");     //错误代码描述
            if ("SUCCESS".equals(result_code)) {
                //表示退款申请接受成功，结果通过退款查询接口查询
                //修改用户订单状态为退款申请中或已退款。退款异步通知根据需求，可选
                //
                return ResultMap.ok("退款申请成功");
            } else {
                logger.info("订单号:{}错误信息:{}", orderNo, err_code_des);
                return ResultMap.error(err_code_des);
            }
        } else {
            logger.info("订单号:{}错误信息:{}", orderNo, return_msg);
            return ResultMap.error(return_msg);
        }
    }

}

定义通用返回结果集 ResultMap

package com.annaru.common.result;

import org.apache.http.HttpStatus;

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

/**
 * @Description 通用返回结果集
 * @Author 
 * @Date 2018/6/12 15:13
 */
public class ResultMap extends HashMap<String, Object> {
    public ResultMap() {
        put("state", true);
        put("code", 0);
        put("msg", "success");
    }

    public static ResultMap error(int code, String msg) {
        ResultMap r = new ResultMap();
        r.put("state", false);
        r.put("code", code);
        r.put("msg", msg);
        return r;
    }

    public static ResultMap error(String msg) {
        return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, msg);
    }

    public static ResultMap error() {
        return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, "未知异常，请联系管理员");
    }

    public static ResultMap ok(String msg) {
        ResultMap r = new ResultMap();
        r.put("msg", msg);
        return r;
    }

    public static ResultMap ok(Map<String, Object> par) {
        ResultMap r = new ResultMap();
        r.putAll(par);
        return r;
    }

    public static ResultMap ok() {
        return new ResultMap();
    }

    public ResultMap put(String key, Object value) {
        super.put(key, value);
        return this;
    }

}

6. Swargger2 前后端API接口信息文档

添加依赖

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2artifactId>
    <version>2.9.2</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-uiartifactId>
    <version>2.9.2</version>
</dependency>

创建 swagger.properties 配置文件

# swagger测试项目
swagger.title=各种登陆
# swagger测试案例
swagger.description=邮箱登陆，短信登陆，微信扫码登陆
# 版本
swagger.version=1.0.0

创建配置类

package com.example.demo1.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration//配置类
@PropertySource("classpath:swagger.properties")
@ConfigurationProperties("swagger")
@EnableSwagger2
public class SwaggerConfig {
    private String title;
    private String description;
    private String version;

   //getter and setter

    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any()).build();
    }
    
    public ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title(this.title)
                .description(this.description)
                .version(this.version).build();
    }
}

API类

@Api(tags = "类说明")
 public class TestController {
     @ApiOperation("方法说明")
     public String test(
             @ApiParam(value = "参数说明", required = true)//required 说明是否必需
             @RequestParam String text) {
         return text;
     }
 }

访问网页查看文档

访问：http://localhost:8080/swagger-ui.html

7. ehcache缓存缓存

添加依赖

<!-- cache缓存依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

resources 文件下添加 ehcache.xml 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd" updateCheck="false">
     
    <!--
    磁盘存储:将缓存中暂时不使用的对象,转移到硬盘,类似于Windows系统的虚拟内存
    path:指定在硬盘上存储对象的路径
    path可以配置的目录有：
    user.home（用户的家目录）
    user.dir（用户当前的工作目录）
    java.io.tmpdir（默认的临时目录）
    ehcache.disk.store.dir（ehcache的配置目录）
    绝对路径（如：d:\\ehcache）
    查看路径方法：String tmpDir = System.getProperty("java.io.tmpdir");
   -->
      
    <diskStore path="java.io.tmpdir"/>
      <!--
    defaultCache:默认的缓存配置信息,如果不加特殊说明,则所有对象按照此配置项处理
    maxElementsInMemory:设置了缓存的上限,最多存储多少个记录对象
    eternal:代表对象是否永不过期 (指定true则下面两项配置需为0无限期)
    timeToIdleSeconds:最大的发呆时间 /秒
    timeToLiveSeconds:最大的存活时间 /秒
    overflowToDisk:是否允许对象被写入到磁盘
    说明：下列配置自缓存建立起600秒(10分钟)有效 。
    在有效的600秒(10分钟)内，如果连续120秒(2分钟)未访问缓存，则缓存失效。
    就算有访问，也只会存活600秒。
   -->
      
    <defaultCache maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="600"
                  timeToLiveSeconds="600" overflowToDisk="true"/>
     
      
    <cache name="cache" maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="120"
           timeToLiveSeconds="600" overflowToDisk="true"/>
     
</ehcache>

在程序入口 MyAppRun 类中添加注解 @EnableCaching

@EnableCaching
@SpringBootApplication
public class MyAppRun {
    public static void main(String[] args) {
        SpringApplication.run(MyAppRun.class, args);
    }
}

给需要缓存的方法加注解 (一般在service实现类上)

@Cacheable(value=”accountCache”)

当调用这个方法的时候，会先从一个名叫 accountCache的缓存中查询，如果没有，则执行实际的方法（即查询数库），并将执行的结果存入缓存中，否则返回缓存中的象。这里的缓存中的 key 就是参数 userName，value 是ehcache.xml 文件里定义的<cache>的name属性值，不设置就是默认

@CachePut 作用和配置方法：

@CachePut 的作用 主要针对方法配置，能够根据方法的请求参数对其结果进行缓存，和 @Cacheable 不同的是，它每次都会触发真实方法的调用，多数用于数据的更新。
@CachePut 注释，这个注释可以确保方法被执行，同时方法的返回值也被记录到缓存中，实现缓存与数据库的同步更新。

@CacheEvict 作用和配置方法

@CachEvict 的作用 主要针对方法配置，能够根据一定的条件对缓存进行清空，多用于删除数据

@CacheConfig

所有的@Cacheable（）里面都有一个value＝“xxx”的属性，这显然如果方法多了，写起来也是挺累的，如果可以一次性声明完 那就省事了， 所以，有了@CacheConfig这个配置，@CacheConfig is a class-level annotation that allows to share the cache names，如果你在你的方法写别的名字，那么依然以方法的名字为准。

@CacheConfig("books")
public class BookRepositoryImpl implements BookRepository {
 
  @Cacheable
  public Book findBook(ISBN isbn) {...}
}

@Caching

有时候我们可能组合多个Cache注解使用；比如用户新增成功后，我们要添加id–>user；username—>user；email—>user的缓存；此时就需要@Caching组合多个注解标签了。

@Caching(put = {
@CachePut(value = "user", key = "#user.id"),
@CachePut(value = "user", key = "#user.username"),
@CachePut(value = "user", key = "#user.email")
})
public User save(User user) {

8. Spring-Boot注解详解

@SpringBootApplication

这个注解是Spring Boot最核心的注解，用在 Spring Boot的主类上，标识这是一个 Spring Boot 应用，用来开启 Spring Boot 的各项能力。实际上这个注解是@Configuration,@EnableAutoConfiguration,@ComponentScan三个注解的组合。由于这些注解一般都是一起使用，所以Spring Boot提供了一个统一的注解@SpringBootApplication。

@EnableAutoConfiguration

允许 Spring Boot 自动配置注解，开启这个注解之后，Spring Boot 就能根据当前类路径下的包或者类来配置 Spring Bean。

如：当前类路径下有 Mybatis 这个 JAR 包，MybatisAutoConfiguration 注解就能根据相关参数来配置 Mybatis 的各个 Spring Bean。

@EnableAutoConfiguration实现的关键在于引入了AutoConfigurationImportSelector，其核心逻辑为selectImports方法，逻辑大致如下：

●　从配置文件META-INF/spring.factories加载所有可能用到的自动配置类；

●　去重，并将exclude和excludeName属性携带的类排除；

●　过滤，将满足条件（@Conditional）的自动配置类返回；

@Configuration

用于定义配置类，指出该类是 Bean 配置的信息源，相当于传统的xml配置文件，一般加在主类上。如果有些第三方库需要用到xml文件，建议仍然通过@Configuration类作为项目的配置主类——可以使用@ImportResource注解加载xml配置文件。

@ComponentScan

组件扫描。让spring Boot扫描到Configuration类并把它加入到程序上下文。

@ComponentScan注解默认就会装配标识了@Controller，@Service，@Repository，@Component注解的类到spring容器中。

@Repository

用于标注数据访问组件，即DAO组件。

使用@Repository注解可以确保DAO或者repositories提供异常转译，这个注解修饰的DAO或者repositories类会被ComponetScan发现并配置，同时也不需要为它们提供XML配置项。

@Service

一般用于修饰service层的组件,修饰服务层

@RestController

用于标注控制层组件(如struts中的action)，表示这是个控制器bean,并且是将函数的返回JSON值直接填入HTTP响应体中,是REST风格的控制器；它是@Controller和@ResponseBody的合集。

@Component

泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注,一般用于实体类。

@Bean

相当于XML中的,放在方法的上面，而不是类，意思是产生一个bean,并交给spring管理。

@AutoWired

byType方式。把配置好的Bean拿来用，完成属性、方法的组装，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。

当加上（required=false）时，就算找不到bean也不报错

@Qualifier

当有多个同一类型的Bean时，可以用@Qualifier(“name”)来指定。与@Autowired配合使用

@Resource(name=“name”,type=“type”)

没有括号内内容的话，默认byName。与@Autowired干类似的事。

@RequestMapping

RequestMapping是一个用来处理请求地址映射的注解；提供路由信息，负责URL到Controller中的具体函数的映射，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

@RequestParam

用于注解Controller里面的方法参数
@RequestParam(defaultValue = “默认值”,required = true) --ture表示参数是必须要的

@PathVariable

前端访问以http://localhost:8080/demo/id方式访问，后端方法参数前面必须加上此注解 public String demo(@PathVariable Integer id)

@Profiles

Spring Profiles提供了一种隔离应用程序配置的方式，并让这些配置只能在特定的环境下生效。

任何@Component或@Configuration都能被@Profile标记，从而限制加载它的时机。

@ConfigurationProperties

Spring Boot可使用注解的方式将自定义的properties文件映射到实体bean中，比如config.properties文件。

9. 自定义配置文件类

创建新的maven项目

父包名必须和使用它的项目的父包名一样

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3yFTmBRg-1600694977271)(demo.jpg)]

导入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot<groupId>
        <artifactId>spring-boot-autoconfigure<artifactId>
        <version>2.1.6.RELEASE</version>
    </dependency>
</dependencies>

创建 SayHelloProperties 配置文件属性类

package com.ddz.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * 属性类、从配置文件中读取属性并赋值
 */
@Component
@ConfigurationProperties(prefix = "myhello")
public class SayHelloProperties {
    private String msg;

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

创建 SayHello 核心事件类

所有的具体功能都在这里完成

package com.ddz.config;

/**
 * 核心事件类完成具体功能
 * 返回信息
 */

public class SayHello {
    private String inMsg;

    public String sayHello() {
        return "信息：" + inMsg;
    }

    public String getInMsg() {
        return inMsg;
    }

    public void setInMsg(String inMsg) {
        this.inMsg = inMsg;
    }
}

创建 SayHelloAutoConfiguation 整合类

负责整合属性类和核心事件类

package com.ddz.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;

/**
 * 整合类
 */
@Configuration
@EnableConfigurationProperties({SayHelloProperties.class})
@ConditionalOnClass(SayHello.class)
@ConditionalOnProperty(prefix = "myhello", value = "enabled", matchIfMissing = true)
public class SayHelloAutoConfiguation {
    @Autowired
    private SayHelloProperties sayHelloProperties;

    @Bean
    @ConditionalOnMissingBean(SayHello.class)
    public SayHello creatSayHello() {
        SayHello sayHello = new SayHello();
        sayHello.setInMsg(sayHelloProperties.getMsg());
        return sayHello;
    }
}

使用install 上传到本地

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UApmpn37-1600694977272)(install.jpg)]

在需要使用的项目里导入依赖

<dependency>
    <groupId>com.ddz</groupId>
    <artifactId>myconfig</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

在 application.yml里面添加属性

myhello:
  msg: ddz

在 Controller 里面使用注解就能使用

package com.ddz.controller;

import com.ddz.config.SayHello;
import com.ddz.config.SayHelloAutoConfiguation;
import com.ddz.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
@CrossOrigin //解决跨域
public class UserController {
    @Resource
    private User user;

    @Autowired  
    private SayHello sayHello; //自定义配置文件事件处理类

    @GetMapping("/show")
    public User show() {
        System.out.println(sayHello.sayHello());
        return user;
    }
}

标签：return,String,微信,支付,private,Spring,import,com,public
From： https://blog.51cto.com/loveddz/6159593

Spring-Boot整合微信登陆、微信支付、邮箱发送、支付宝支付和阿里云短信