记录一下曾经写过的P2P金融项目-理财端（PC端）纯代码(续-服务消费者工程)

最新推荐文章于 2023-03-20 10:26:03 发布

武侠㿝卄清

最新推荐文章于 2023-03-20 10:26:03 发布

阅读量697

点赞数

分类专栏： java web开发

本文链接：https://blog.csdn.net/qq_30347133/article/details/109501000

版权

web开发同时被 2 个专栏收录

611 篇文章 2 订阅

订阅专栏

java

574 篇文章 4 订阅

订阅专栏

pom文件：

<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>
        <artifactId>p2p-parent</artifactId>
        <groupId>com.bjpowernode.p2p</groupId>
        <version>1.0.0</version>
        <relativePath>../p2p-parent/pom.xml</relativePath>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>p2p-web</artifactId>
    <packaging>war</packaging>


    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-oxm</artifactId>
        </dependency>

        <!-- servlet及jstl标签库依赖的JAR配置 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.taglibs</groupId>
            <artifactId>taglibs-standard-spec</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.taglibs</groupId>
            <artifactId>taglibs-standard-impl</artifactId>
        </dependency>

        <!-- zookeeper客户端依赖 -->
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
        </dependency>

        <!-- Log4j2依赖的JAR配置 -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-jcl</artifactId>
        </dependency>


        <!--dubbo2.6.0-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
        </dependency>

        <!-- 加载apache commons包start -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>

        <!-- 加载jackson包 -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
        </dependency>
        <!-- 文件IO操作包start -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
        </dependency>

        <!-- httpclient4.5操作包start -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
        </dependency>

        <!-- 阿里巴巴json解析包start -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
        </dependency>

        <!--P2P的接口工程-->
        <dependency>
            <groupId>com.bjpowernode.p2p</groupId>
            <artifactId>p2p-exterface</artifactId>
            <version>1.0.0</version>
        </dependency>

        <!--p2p-common公共工程-->
        <dependency>
            <groupId>com.bjpowernode.p2p</groupId>
            <artifactId>p2p-common</artifactId>
            <version>1.0.0</version>
        </dependency>

        <!-- google生成二维码依赖 -->
        <dependency>
            <groupId>com.google.zxing</groupId>
            <artifactId>core</artifactId>
            <version>3.0.0</version>
        </dependency>

        <dependency>
            <groupId>com.google.zxing</groupId>
            <artifactId>javase</artifactId>
            <version>3.0.0</version>
        </dependency>
    </dependencies>
</project>

java-web包

package com.bjpowernode.p2p.web;

import com.bjpowernode.p2p.common.constant.Constants;
import com.bjpowernode.p2p.model.user.User;
import com.bjpowernode.p2p.model.vo.ResultObject;
import com.bjpowernode.p2p.service.loan.BidInfoService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

/**
 * ClassName:BidInfoController
 * Package:com.bjpowernode.p2p.web
 * Description:
 *
 * @date:2018/9/21 14:30
 * @author:guoxin@bjpowernode.com
 */
@Controller
public class BidInfoController {

    @Autowired
    private BidInfoService bidInfoService;

    @RequestMapping(value = "/loan/invest")
    public @ResponseBody Object invest(HttpServletRequest request,
                                       @RequestParam (value = "loanId",required = true) Integer loanId,
                                       @RequestParam (value = "bidMoney",required = true) Double bidMoney) {
        Map<String,Object> retMap = new HashMap<String,Object>();

        //从session中获取用户的信息
        User sesionUser = (User) request.getSession().getAttribute(Constants.SESSION_USER);

        //准备请求参数
        Map<String,Object> paramMap = new HashMap<String,Object>();
        //用户标识
        paramMap.put("uid",sesionUser.getId());
        //产品标识
        paramMap.put("loanId",loanId);
        //投资金额
        paramMap.put("bidMoney",bidMoney);
        //手机号码
        paramMap.put("phone",sesionUser.getPhone());


        //用户投资（用户标识，产品标识，投资金额） -> 返回结果ResultObject
        ResultObject resultObject = bidInfoService.invest(paramMap);

        //判断是否成功
        if (StringUtils.equals(Constants.SUCCESS,resultObject.getErrorCode())) {
            retMap.put(Constants.ERROR_MESSAGE,Constants.OK);
        } else {
            retMap.put(Constants.ERROR_MESSAGE,"投资人数过多，请稍后重试...");
            return retMap;
        }


        return retMap;
    }
}

package com.bjpowernode.p2p.web;

import com.bjpowernode.p2p.common.constant.Constants;
import com.bjpowernode.p2p.model.loan.LoanInfo;
import com.bjpowernode.p2p.service.loan.BidInfoService;
import com.bjpowernode.p2p.service.loan.LoanInfoService;
import com.bjpowernode.p2p.service.user.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * ClassName:IndexController
 * Package:com.bjpowernode.p2p.web
 * Description:
 *
 * @date:2018/9/17 11:07
 * @author:guoxin@bjpowernode.com
 */
@Controller
public class IndexController {

    @Autowired
    private LoanInfoService loanInfoService;

    @Autowired
    private UserService userService;

    @Autowired
    private BidInfoService bidInfoService;

    @RequestMapping(value = "/index")
    public String index(HttpServletRequest request, Model model) {

        //获取历史年化收益率
        Double historyAverageRate = loanInfoService.queryHistoryAverageRate();
        model.addAttribute(Constants.HISTORY_AVERAGE_RATE,historyAverageRate);

        //获取平台注册总人数
        Long allUserCount = userService.queryAllUserCount();
        model.addAttribute(Constants.ALL_USER_COUNT,allUserCount);

        //获取平台累计投资金额
        Double allBidMoney = bidInfoService.queryAllBidMoney();
        model.addAttribute(Constants.ALL_BID_MONEY,allBidMoney);

        //将以下查询看成是一个分页，实际功能：根据产品类型查询产品信息显示前几个
        //数据持久层用户的是limit函数 limit 起始下标,截取长度
        //loanInfoService.queryLoanInfoListByProductType(产品类型，页码，每页显示条数);

        Map<String,Object> paramMap = new HashMap<String,Object>();

        //页码：起始下标
        paramMap.put("currentPage",0);


        //获取新手宝产品:产品类型：0，显示第1页，每页显示1个
        paramMap.put("productType",Constants.PRODUCT_TYPE_X);
        paramMap.put("pageSize",1);
        List<LoanInfo> xLoanInfoList = loanInfoService.queryLoanInfoListByProductType(paramMap);


        //获取优选产品：产品类型：1，显示第1页，每页显示4个
        paramMap.put("productType",Constants.PRODUCT_TYPE_U);
        paramMap.put("pageSize",4);
        List<LoanInfo> uLoanInfoList = loanInfoService.queryLoanInfoListByProductType(paramMap);


        //获取散标产品：产品类型：2，显示第2页，每页显示8个
        paramMap.put("productType",Constants.PRODUCT_TYPE_S);
        paramMap.put("pageSize",8);
        List<LoanInfo> sLoanInfoList = loanInfoService.queryLoanInfoListByProductType(paramMap);

        model.addAttribute("xLoanInfoList",xLoanInfoList);
        model.addAttribute("uLoanInfoList",uLoanInfoList);
        model.addAttribute("sLoanInfoList",sLoanInfoList);


        return "index";
    }


}

package com.bjpowernode.p2p.web;

import com.bjpowernode.p2p.common.constant.Constants;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.imageio.ImageIO;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;

/**
 * ClassName:JCaptcha
 * Package:com.bjpowernode.p2p.web
 * Description:
 *
 * @date:2018/9/18 15:40
 * @author:guoxin@bjpowernode.com
 */
@Controller
public class JCaptchaController {


    public static final int WIDTH = 120;
    /**
     * 图片高度：50px
     */
    public static final int HEIGHT = 50;
    /**
     * 处理图片验证码方法
     *
     * @param request
     * @param response
     */
    @RequestMapping(value="/jcaptcha/captcha")
    public void handleCaptchaRequest(HttpServletRequest request, HttpServletResponse response) {
            //生成6位随机验证码
            String captcha = this.getRandomCode(3);
        try {
            //创建字节数组输出流
            ByteArrayOutputStream jpegOutputStream = new ByteArrayOutputStream();
            //创建图片缓存对象,BufferedImage.TYPE_INT_RGB ： 表示一个图像，该图像具有整数像素的 8 位 RGB 颜色
            BufferedImage bufferedImage = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
            //获取图片的画布
            Graphics graphics = bufferedImage.getGraphics();
            //设置画布背景色
            graphics.setColor(Color.GREEN);
            //设置画布填充区域
            graphics.fillRect(0, 0, WIDTH, HEIGHT);
            //边框区域
            graphics.drawRect(1, 1, WIDTH - 2, HEIGHT - 2);
            //设置字体颜色
            graphics.setColor(Color.BLACK);
            //设置字体样式
            graphics.setFont(new Font("微软雅黑", Font.ITALIC, 32));
            //填充数据
            graphics.drawString(captcha, 10, 38);
            //将生成的验证码存放到session中
            request.getSession().setAttribute(Constants.CAPTCHA, captcha);

            ImageIO.write(bufferedImage, "jpeg", jpegOutputStream);
            byte[] captchaChallengeAsJpeg = jpegOutputStream.toByteArray();
            //将验证码输出到页面
            response.setHeader("Cache-Control", "no-store");
            response.setHeader("Pragma", "no-cache");
            response.setDateHeader("Expires", 0L);
            response.setContentType("image/jpeg");
            ServletOutputStream respOs = response.getOutputStream();
            respOs.write(captchaChallengeAsJpeg);
            respOs.flush();
            respOs.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 生成0-9，a-z,A-Z的随机字符串
     * @param count
     * @return
     */
    private String getRandomCode(int count) {
        String[] array = {"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","0","1","2","3","4","5","6","7","8","9"};

        StringBuilder result = new StringBuilder();

        for (int i = 0; i < count; i++) {
            //生成一个下标0-61之间一个整数
            int index = (int) Math.round(Math.random() * 61);
            //从array数组中获取该下标字符放到result中
            result.append(array[index]);
        }
        return result.toString();
    }

}

package com.bjpowernode.p2p.web;

import com.bjpowernode.p2p.common.constant.Constants;
import com.bjpowernode.p2p.model.loan.BidInfo;
import com.bjpowernode.p2p.model.loan.LoanInfo;
import com.bjpowernode.p2p.model.user.FinanceAccount;
import com.bjpowernode.p2p.model.user.User;
import com.bjpowernode.p2p.model.vo.BidUserTop;
import com.bjpowernode.p2p.model.vo.PaginatinoVO;
import com.bjpowernode.p2p.service.loan.BidInfoService;
import com.bjpowernode.p2p.service.loan.LoanInfoService;
import com.bjpowernode.p2p.service.user.FinanceAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * ClassName:LoanInfoController
 * Package:com.bjpowernode.p2p.web
 * Description:
 *
 * @date:2018/9/18 11:57
 * @author:guoxin@bjpowernode.com
 */
@Controller
public class LoanInfoController {

    @Autowired
    private LoanInfoService loanInfoService;

    @Autowired
    private BidInfoService bidInfoService;

    @Autowired
    private FinanceAccountService financeAccountService;

    @RequestMapping(value = "/loan/loan")
    public String loan(HttpServletRequest request,Model model,
                       @RequestParam (value = "ptype",required = false) Integer ptype,
                       @RequestParam (value = "currentPage",required = false) Integer currentPage) {

        //判断当前页码是否为空，为空，默认值为第1页
        if (null == currentPage) {
            //默认为第1页
            currentPage = 1;
        }

        //准备分页查询参数
        Map<String,Object> paramMap = new HashMap<String,Object>();

        if (null != ptype) {
            //产品类型
            paramMap.put("productType",ptype);
        }

        int pageSize = 9;

        //起始下标
        paramMap.put("currentPage",(currentPage -1) * pageSize);

        //截取长度，每页显示条数
        paramMap.put("pageSize",pageSize);

        //分页查询产品信息列表(产品类型，页码，每页显示几条)  -> 返回分页模型对象（总记录条数、当前页要显示的数据）
        PaginatinoVO<LoanInfo> paginatinoVO = loanInfoService.queryLoanInfoByPage(paramMap);

        //计算总页数
        int totalPage = paginatinoVO.getTotal().intValue() / pageSize;

        //再次求余
        int mod = paginatinoVO.getTotal().intValue() % pageSize;
        if (mod > 0) {
            totalPage = totalPage + 1;
        }

        //总记录数
        model.addAttribute("totalRows",paginatinoVO.getTotal());
        //总页数
        model.addAttribute("totalPage",totalPage);
        //每页显示的数据
        model.addAttribute("loanInfoList",paginatinoVO.getDataList());
        //当前页码
        model.addAttribute("currentPage",currentPage);

        if (null != ptype) {
            //产品类型
            model.addAttribute("ptype",ptype);
        }


        //用户投资排行榜
        List<BidUserTop> bidUserTopList = bidInfoService.queryBidUserTop();
        model.addAttribute("bidUserTopList",bidUserTopList);


        return "loan";
    }


    @RequestMapping(value = "/loan/loanInfo")
    public String loanInfo(HttpServletRequest request,Model model,
                           @RequestParam (value = "id",required = true) Integer id) {

        //根据产品标识获取产品的详情
        LoanInfo loanInfo = loanInfoService.queryLoanInfoById(id);

        //根据产品标识获取该产品的所有投资记录
        List<BidInfo> bidInfoList = bidInfoService.queryBidInfoListByLoanId(id);

        model.addAttribute("loanInfo",loanInfo);
        model.addAttribute("bidInfoList",bidInfoList);

        //获取当前用户的信息
        User sessionUser = (User) request.getSession().getAttribute(Constants.SESSION_USER);

        //判断用户是否登录
        if (null != sessionUser) {

            //获取当前用户的帐户可用余额
            FinanceAccount financeAccount = financeAccountService.queryFinanceAccountByUid(sessionUser.getId());
            model.addAttribute("financeAccount",financeAccount);
        }




        return "loanInfo";
    }
}

package com.bjpowernode.p2p.web;

import com.alibaba.fastjson.JSONObject;
import com.bjpowernode.p2p.common.constant.Constants;
import com.bjpowernode.p2p.common.util.DateUtils;
import com.bjpowernode.p2p.common.util.HttpClientUtils;
import com.bjpowernode.p2p.model.loan.RechargeRecord;
import com.bjpowernode.p2p.model.user.User;
import com.bjpowernode.p2p.service.loan.OnlyNumberService;
import com.bjpowernode.p2p.service.loan.RechargeRecordService;
import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.WriterException;
import com.google.zxing.client.j2se.MatrixToImageWriter;
import com.google.zxing.common.BitMatrix;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * ClassName:RechargeRecordController
 * Package:com.bjpowernode.p2p.web
 * Description:
 *
 * @date:2018/9/26 10:50
 * @author:guoxin@bjpowernode.com
 */
@Controller
public class RechargeRecordController {

    @Autowired
    private RechargeRecordService rechargeRecordService;


    @Autowired
    private OnlyNumberService onlyNumberService;


    @RequestMapping(value = "/loan/toAlipayRecharge")
    public String toAlipayRecharge(HttpServletRequest request, Model model,
                                   @RequestParam (value = "rechargeMoney",required = true) Double rechargeMoney) {

        //从session中获取用户的信息
        User sessionUser = (User) request.getSession().getAttribute(Constants.SESSION_USER);

        //生成一个全局唯一充值订单号 = 时间戳 + redis全局唯一数字
        String rechargeNo = DateUtils.getTimeStamp() + onlyNumberService.getOnlyNumber();

        //生成充值记录（状态为：充值中）
        RechargeRecord rechargeRecord = new RechargeRecord();
        rechargeRecord.setUid(sessionUser.getId());
        rechargeRecord.setRechargeNo(rechargeNo);
        rechargeRecord.setRechargeMoney(rechargeMoney);
        rechargeRecord.setRechargeTime(new Date());
        rechargeRecord.setRechargeStatus("0");
        rechargeRecord.setRechargeDesc("支付宝充值");

        int addRechargeCount = rechargeRecordService.addRechargeRecord(rechargeRecord);

        if (addRechargeCount > 0) {

            //向pay工程的支付方法传递参数
            model.addAttribute("p2p_pay_alipay_url","http://localhost:9090/pay/api/alipay");
            model.addAttribute("rechargeNo",rechargeNo);
            model.addAttribute("rechargeMoney",rechargeMoney);
            model.addAttribute("subject","支付宝充值");

        } else {

            model.addAttribute("trade_msg","充值人数过多，请稍后重试...");
            return "toRechargeBack";
        }


        return "toAlipay";
    }

    @RequestMapping(value = "/loan/alipayBack")
    public String alipayBack(HttpServletRequest request,Model model,
                             @RequestParam (value = "signVerified",required = true) String signVerified,
                             @RequestParam (value = "out_trade_no",required = true) String out_trade_no,
                             @RequestParam (value = "total_amount",required = true) Double total_amount) {

        System.out.println("-----------p2p-web------alipayBack-----------");

        //判断验证签名是否成功
        if (StringUtils.equals(Constants.SUCCESS,signVerified)) {
            //成功

            Map<String,Object> paramMap = new HashMap<String,Object>();
            paramMap.put("out_trade_no",out_trade_no);

            //调用pay工程的订单查询接口 -> 返回订单的状态
            String jsonString = HttpClientUtils.doPost("http://localhost:9090/pay/api/alipayQuery", paramMap);

            //使用fastJson解析json格式的字符串
            //将json格式的字符串转换为JSON对象
            JSONObject jsonObject = JSONObject.parseObject(jsonString);

            //获取指定key的value值
            JSONObject tradeQueryResponse = jsonObject.getJSONObject("alipay_trade_query_response");

            //获取通信标识code
            String code = tradeQueryResponse.getString("code");

            //判断通信是否成功
            if (StringUtils.equals("10000",code)) {

                //通信成功:获取业务处理结果trade_status
                String tradeStatus = tradeQueryResponse.getString("trade_status");

                /*交易状态：
                WAIT_BUYER_PAY（交易创建，等待买家付款）
                TRADE_CLOSED（未付款交易超时关闭，或支付完成后全额退款）
                TRADE_SUCCESS（交易支付成功）
                TRADE_FINISHED（交易结束，不可退款）*/

                if ("TRADE_CLOSED".equals(tradeStatus)) {
                    //更新充值记录的状态为2充值失败
                    RechargeRecord updateRechargeRecord = new RechargeRecord();
                    updateRechargeRecord.setRechargeNo(out_trade_no);
                    updateRechargeRecord.setRechargeStatus("2");
                    int modifyRechargeCount = rechargeRecordService.modifyRechargeRecordByRechargeNo(updateRechargeRecord);

                    if (modifyRechargeCount < 0) {
                        model.addAttribute("trade_msg","充值人数过多，请稍后重试...");
                        return "toRechargeBack";
                    }

                }

                if ("TRADE_SUCCESS".equals(tradeStatus)) {
                    User sessionUser = (User) request.getSession().getAttribute(Constants.SESSION_USER);
                    paramMap.put("uid",sessionUser.getId());
                    paramMap.put("rechargeNo",out_trade_no);
                    paramMap.put("rechargeMoney",total_amount);

                    //支付宝扣款成功：给用户充值【1.更新帐户可用余额 2.更新充值记录的状态为1充值成功】(用户标识，充值订单号，充值金额)
                    int rechargeCount = rechargeRecordService.recharge(paramMap);

                    if (rechargeCount < 0) {
                        model.addAttribute("trade_msg","充值人数过多，请稍后重试...");
                        return "toRechargeBack";
                    }
                }


            } else {

                //通信失败
                model.addAttribute("trade_msg","通信失败，请稍后重试...");
                return "toRechargeBack";
            }


        } else {
            //失败
            model.addAttribute("trade_msg","充值人数过多，请稍后重试...");
            return "toRechargeBack";
        }


        return "redirect:/loan/myCenter";
    }






    @RequestMapping (value = "/loan/toWxpayRecharge")
    public String toWxpayRecharge(HttpServletRequest request, Model model,
                                  @RequestParam (value = "rechargeMoney",required = true) Double rechargeMoney) {

        //从session中获取用户的信息
        User sessionUser = (User) request.getSession().getAttribute(Constants.SESSION_USER);

        //生成一个全局唯一充值订单号 = 时间戳 + redis全局唯一数字
        String rechargeNo = DateUtils.getTimeStamp() + onlyNumberService.getOnlyNumber();

        //生成充值记录（状态为：充值中）
        RechargeRecord rechargeRecord = new RechargeRecord();
        rechargeRecord.setUid(sessionUser.getId());
        rechargeRecord.setRechargeNo(rechargeNo);
        rechargeRecord.setRechargeMoney(rechargeMoney);
        rechargeRecord.setRechargeTime(new Date());
        rechargeRecord.setRechargeStatus("0");
        rechargeRecord.setRechargeDesc("微信充值");

        int addRechargeCount = rechargeRecordService.addRechargeRecord(rechargeRecord);

        if(addRechargeCount > 0) {

            //跳转至展示二维码页面
            model.addAttribute("rechargeNo",rechargeNo);
            model.addAttribute("rechargeMoney",rechargeMoney);
            model.addAttribute("rechargeTime",new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));

        } else {
            model.addAttribute("trade_msg","充值人数过多，请稍后重试...");
            return "toRechargeBack";
        }


        return "generateQRCode";
    }


    @RequestMapping(value = "/loan/generateQRCode")
    public void generateQRCode(HttpServletRequest request, HttpServletResponse response,
                               @RequestParam (value = "rechargeMoney",required = true) Double rechargeMoney,
                               @RequestParam (value = "rechargeNo",required = true) String rechargeNo) throws IOException, WriterException {

        Map<String,Object> paramMap = new HashMap<String,Object>();

        paramMap.put("out_trade_no",rechargeNo);
        paramMap.put("total_fee",rechargeMoney);
        paramMap.put("body","微信充值");


        //调用pay工程的统一下单接口 -> 返回参数，包含code_url
        String jsonString = HttpClientUtils.doPost("http://localhost:9090/pay/api/wxpay", paramMap);

        //使用fastJson解析json格式的字符串
        //将json格式的字符串转换为json对象
        JSONObject jsonObject = JSONObject.parseObject(jsonString);

        //获取通信标识return_code
        String returnCode = jsonObject.getString("return_code");

        //判断通信是否成功
        if (StringUtils.equals(Constants.SUCCESS,returnCode)) {

            //获取业务处理结果
            String resultCode = jsonObject.getString("result_code");

            //判断业务处理结果
            if (StringUtils.equals(Constants.SUCCESS,resultCode)) {

                //将code_url转换为二维码
                String codeUrl = jsonObject.getString("code_url");

                Map<EncodeHintType,Object> hintMap = new HashMap<EncodeHintType, Object>();
                hintMap.put(EncodeHintType.CHARACTER_SET,"UTF-8");
                //创建一个矩阵对象
                BitMatrix bitMatrix = new MultiFormatWriter().encode(codeUrl, BarcodeFormat.QR_CODE,200,200,hintMap);

                OutputStream outputStream = response.getOutputStream();

                MatrixToImageWriter.writeToStream(bitMatrix,"png",outputStream);

            } else {
                response.sendRedirect(request.getContextPath() + "/toRechargeBack.jsp");
            }

        } else {
            response.sendRedirect(request.getContextPath() + "/toRechargeBack.jsp");
        }

    }
}

package com.bjpowernode.p2p.web;

import com.alibaba.fastjson.JSONObject;
import com.bjpowernode.p2p.common.constant.Constants;
import com.bjpowernode.p2p.common.util.HttpClientUtils;
import com.bjpowernode.p2p.config.Config;
import com.bjpowernode.p2p.model.user.FinanceAccount;
import com.bjpowernode.p2p.model.user.User;
import com.bjpowernode.p2p.model.vo.ResultObject;
import com.bjpowernode.p2p.service.loan.BidInfoService;
import com.bjpowernode.p2p.service.loan.LoanInfoService;
import com.bjpowernode.p2p.service.user.FinanceAccountService;
import com.bjpowernode.p2p.service.user.UserService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;

/**
 * ClassName:UserController
 * Package:com.bjpowernode.p2p.web
 * Description:
 *
 * @date:2018/9/18 16:03
 * @author:guoxin@bjpowernode.com
 */
@Controller
//@RestController  // 等同于 @Controller + 类中每个方法响应的都JSON对象@ResponseBody
public class UserController {

    @Autowired
    private UserService userService;

    @Autowired
    private LoanInfoService loanInfoService;

    @Autowired
    private BidInfoService bidInfoService;

    @Autowired
    private FinanceAccountService financeAccountService;

    @Autowired
    private Config config;

    /**
     * 验证手机号是否存在
     * http://lcoalhost:8080/p2p/loan/checkPhone
     * @param request
     * @param phone 必填
     * @return
     */
    @RequestMapping(value = "/loan/checkPhone")
    @ResponseBody
    public Object checkPhone(HttpServletRequest request,
                                           @RequestParam (value = "phone",required = true) String phone) {
        Map<String,Object> retMap = new HashMap<String,Object>();

        //查询手机号码是否重复 -》 返回Boolean|User**|int
        //根据手机号查询用户信息
        User user = userService.queryUserByPhone(phone);

        //判断用户是否存在
        if (null != user) {
            retMap.put(Constants.ERROR_MESSAGE,"该手机号码已被注册，请更换手机号码");
            return retMap;
        }

        retMap.put(Constants.ERROR_MESSAGE,Constants.OK);

        return retMap;
    }

//    @RequestMapping(value = "/loan/checkCaptcha",method = RequestMethod.POST) //等同于 @PostMapping(value="/loan/checkCaptcha")
    @PostMapping(value = "/loan/checkCaptcha")
    @ResponseBody
    public Map<String,Object> checkCaptcha(HttpServletRequest request,
                                           @RequestParam (value = "captcha",required = true) String captcha) {
        Map<String,Object> retMap = new HashMap<String,Object>();

        //获取session中的图形验证码
        String sessionCaptcha = (String) request.getSession().getAttribute(Constants.CAPTCHA);

        //验证图形验证码是否一致
        if (!StringUtils.equalsIgnoreCase(sessionCaptcha,captcha)) {
            retMap.put(Constants.ERROR_MESSAGE,"请输入正确的图形验证码");
            return retMap;
        }

        retMap.put(Constants.ERROR_MESSAGE,Constants.OK);

        return retMap;
    }


    @RequestMapping(value = "/loan/register")
    @ResponseBody
    public Object regiter(HttpServletRequest request,
                          @RequestParam(value = "phone",required = true) String phone,
                          @RequestParam(value = "loginPassword",required = true) String loginPassword,
                          @RequestParam(value = "replayLoginPassword",required = true) String replayLoginPassword) {

        Map<String,Object> retMap = new HashMap<String,Object>();

        //验证参数
        if (!Pattern.matches("^1[1-9]\\d{9}$",phone)) {
            retMap.put(Constants.ERROR_MESSAGE,"请输入正确的手机号码");
            return retMap;
        }

        if (!StringUtils.equals(loginPassword,replayLoginPassword)) {
            retMap.put(Constants.ERROR_MESSAGE,"两次密码输入不一致");
            return retMap;
        }


        //用户的注册(手机号，登录密码)【1.新增用户信息 2.开立帐户】 -> 返回Boolean|int|结果对象ResultObject
        ResultObject resultObject = userService.register(phone,loginPassword);

        //判断是否注册成功
        if (!StringUtils.equals(Constants.SUCCESS,resultObject.getErrorCode())) {
            retMap.put(Constants.ERROR_MESSAGE,"注册失败，请稍后重试...");
            return retMap;
        }


        //将用户的信息存放到session中
        request.getSession().setAttribute(Constants.SESSION_USER,userService.queryUserByPhone(phone));

        retMap.put(Constants.ERROR_MESSAGE,Constants.OK);


        return retMap;
    }

    @RequestMapping(value = "/loan/verifyRealName")
    @ResponseBody
    public Object verifyRealName(HttpServletRequest request,
                                 @RequestParam (value = "realName",required = true) String realName,
                                 @RequestParam (value = "idCard",required = true) String idCard,
                                 @RequestParam (value = "replayIdCard",required = true) String replayIdCard) {
        Map<String,Object> retMap = new HashMap<String,Object>();

        //验证参数
        if (!Pattern.matches("^[\\u4e00-\\u9fa5]{0,}$",realName)) {
            retMap.put(Constants.ERROR_MESSAGE,"真实姓名只支持中文");
            return retMap;
        }

        if (!Pattern.matches("(^\\d{15}$)|(^\\d{18}$)|(^\\d{17}(\\d|X|x)$)",idCard)) {
            retMap.put(Constants.ERROR_MESSAGE,"请输入正确的身份证号码");
            return retMap;
        }

        if (!StringUtils.equals(idCard,replayIdCard)) {
            retMap.put(Constants.ERROR_MESSAGE,"两次输入身份证号码不一致");
            return retMap;
        }


        //准备实名认证的参数
        Map<String,Object> paramMap = new HashMap<String,Object>();

        //实名认证appkey
        paramMap.put("appkey",config.getRealNameAppkey());

        //真实姓名
        paramMap.put("realName",realName);

        //身份证号码
        paramMap.put("cardNo",idCard);

        //发送请求验证用户真实信息 -> 返回json格式的字符串
        String jsonString = HttpClientUtils.doPost(config.getRealNameUrl(), paramMap);
//        String jsonString = "{\"code\":\"10000\",\"charge\":false,\"remain\":1305,\"msg\":\"查询成功\",\"result\":{\"error_code\":0,\"reason\":\"成功\",\"result\":{\"realname\":\"乐天磊\",\"idcard\":\"350721197702134399\",\"isok\":true}}}";

        //解析json格式字符串，使用fastjson
        //将json格式的字符串转换为JSON对象
        JSONObject jsonObject = JSONObject.parseObject(jsonString);

        //获取指定key所对应的value,获取code通信标识
        String code = jsonObject.getString("code");

        //判断通信是否成功
        if (StringUtils.equals("10000",code)) {
            //通信成功

            //获取isok是否匹配标识
            Boolean isok = jsonObject.getJSONObject("result").getJSONObject("result").getBoolean("isok");

            //判断真实姓名与身份证号码是否一致
            if (isok) {
                //从session中获取用户的信息
                User sessionUser = (User) request.getSession().getAttribute(Constants.SESSION_USER);

                //更新用户的信息
                User updateUser = new User();
                updateUser.setId(sessionUser.getId());
                updateUser.setName(realName);
                updateUser.setIdCard(idCard);
                int modifyUserCount = userService.modifyUserById(updateUser);

                if (modifyUserCount > 0) {
                    //更新session中用户的信息
                    request.getSession().setAttribute(Constants.SESSION_USER,userService.queryUserByPhone(sessionUser.getPhone()));

                    retMap.put(Constants.ERROR_MESSAGE,Constants.OK);

                } else {
                    retMap.put(Constants.ERROR_MESSAGE,"系统繁忙，请稍后重试...");
                    return retMap;
                }

            } else {

                retMap.put(Constants.ERROR_MESSAGE,"真实姓名与身份证号码不匹配");
                return retMap;
            }


        } else {
            //难信失败
            retMap.put(Constants.ERROR_MESSAGE,"通信失败，请稍后重试...");
            return retMap;
        }


        return retMap;
    }


    @RequestMapping(value = "/loan/myFinanceAccount")
    @ResponseBody
    public FinanceAccount myFinanceAccount(HttpServletRequest request) {

        //从session中获取用户信息
        User sessionUser = (User) request.getSession().getAttribute(Constants.SESSION_USER);

        return financeAccountService.queryFinanceAccountByUid(sessionUser.getId());
    }


    @RequestMapping(value = "/loan/login")
    @ResponseBody
    public Object login(HttpServletRequest request,
                        @RequestParam (value = "phone",required = true) String phone,
                        @RequestParam (value = "loginPassword",required = true) String loginPassword) {
        Map<String,Object> retMap = new HashMap<String,Object>();

        //验证手机号码格式
        if (!Pattern.matches("^1[1-9]\\d{9}$",phone)) {
            retMap.put(Constants.ERROR_MESSAGE,"请输入正确的手机号码");
            return retMap;
        }


        //用户登录【1.根据手机号和密码查询用户 2.更新最近登录时间】（手机号，密码） -> 返回User|Map
        User user = userService.login(phone,loginPassword);

        //判断用户是否存在
        if (null == user) {
            retMap.put(Constants.ERROR_MESSAGE,"用户名或密码输入有误，请重新输入");
            return retMap;
        }

        //将用户的信息存放到session中
        request.getSession().setAttribute(Constants.SESSION_USER,user);

        retMap.put(Constants.ERROR_MESSAGE,Constants.OK);
        return retMap;
    }


    @RequestMapping (value = "/loan/logout")
    public String logout(HttpServletRequest request) {

        //让session失效或者清除指定session中key的值
        request.getSession().invalidate();

//        request.getSession().removeAttribute(Constants.SESSION_USER);

        return "redirect:/index";
    }


    @RequestMapping(value = "/loan/loadStat")
    public @ResponseBody Object loadStat(HttpServletRequest request) {

        Map<String,Object> retMap = new HashMap<String,Object>();

        //历史平均年化收益率
        Double historyAverageRate = loanInfoService.queryHistoryAverageRate();

        //平台注册总人数
        Long allUserCount = userService.queryAllUserCount();

        //累计投资金额
        Double allBidMoney = bidInfoService.queryAllBidMoney();

        retMap.put(Constants.HISTORY_AVERAGE_RATE,historyAverageRate);
        retMap.put(Constants.ALL_USER_COUNT,allUserCount);
        retMap.put(Constants.ALL_BID_MONEY,allBidMoney);


        return retMap;
    }


    @RequestMapping(value = "/loan/myCenter")
    public String myCenter(HttpServletRequest request, Model model) {

        //从session中获取用户标识
        User sessionUser = (User) request.getSession().getAttribute(Constants.SESSION_USER);

        //根据用户标识获取帐户可用余额
        FinanceAccount financeAccount = financeAccountService.queryFinanceAccountByUid(sessionUser.getId());

        model.addAttribute("financeAccount",financeAccount);


        return "myCenter";
    }
}

p2p-config

package com.bjpowernode.p2p.config;

/**
 * ClassName:Config
 * Package:com.bjpowernode.p2p.config
 * Description:
 *
 * @date:2018/9/20 15:14
 * @author:guoxin@bjpowernode.com
 */
public class Config {

    /**
     * 实名认证的key
     */
    private String realNameAppkey;
    /**
     * 实名认证的URL
     */
    private String realNameUrl;

    public String getRealNameAppkey() {
        return realNameAppkey;
    }

    public void setRealNameAppkey(String realNameAppkey) {
        this.realNameAppkey = realNameAppkey;
    }

    public String getRealNameUrl() {
        return realNameUrl;
    }

    public void setRealNameUrl(String realNameUrl) {
        this.realNameUrl = realNameUrl;
    }
}

interceptor 拦截器

package com.bjpowernode.p2p.interceptor;

import com.bjpowernode.p2p.common.constant.Constants;
import com.bjpowernode.p2p.model.user.User;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * ClassName:UserInterceptor
 * Package:com.bjpowernode.p2p.interceptor
 * Description:
 *
 * @date:2018/9/27 14:33
 * @author:guoxin@bjpowernode.com
 */
public class UserInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //从session中获取用户的信息
        User sessionUser = (User) request.getSession().getAttribute(Constants.SESSION_USER);

        //判断用户是否登录
        if (null == sessionUser) {
            //跳转至登录页面
            response.sendRedirect(request.getContextPath() + "/login.jsp");
            return false;
        }

        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

resources包—applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/tx
            http://www.springframework.org/schema/tx/spring-tx.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--加载系统配置文件-->
    <context:property-placeholder location="classpath:config.properties"/>

    <!--加载bean对象-->
    <bean class="com.bjpowernode.p2p.config.Config">
        <property name="realNameAppkey" value="${realNameAppkey}"/>
        <property name="realNameUrl" value="${realNameUrl}"/>
    </bean>

    <!-- 导入spring mvc配置 -->
    <import resource="applicationContext-mvc.xml" />
    <!-- 导入服务消费者配置 -->
    <import resource="applicationContext-dubbo-consumer.xml" />
</beans>

applicationContext-dubbo-consumer.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://code.alibabatech.com/schema/dubbo
            http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
    <!-- 配置应用名称 -->
    <dubbo:application name="p2p"/>
    <!-- 配置注册中心 -->
    <dubbo:registry protocol="zookeeper" address="47.101.55.220:2181"/>


    <!--产品业务-->
    <dubbo:reference id="loanInfoService" interface="com.bjpowernode.p2p.service.loan.LoanInfoService" version="1.0.0" check="false"></dubbo:reference>

    <!--用户业务-->
    <dubbo:reference id="userService" interface="com.bjpowernode.p2p.service.user.UserService" check="false" version="1.0.0"></dubbo:reference>

    <!--投资业务-->
    <dubbo:reference id="bidInfoService" interface="com.bjpowernode.p2p.service.loan.BidInfoService" version="1.0.0" check="false"></dubbo:reference>

    <!--帐户业务-->
    <dubbo:reference id="financeAccountService" interface="com.bjpowernode.p2p.service.user.FinanceAccountService" version="1.0.0" check="false"></dubbo:reference>

    <!--充值业务-->
    <dubbo:reference id="rechargeRecordService" interface="com.bjpowernode.p2p.service.loan.RechargeRecordService" version="1.0.0" check="false"></dubbo:reference>

    <!--唯一数字业务-->
    <dubbo:reference id="onlyNumberService" interface="com.bjpowernode.p2p.service.loan.OnlyNumberService" version="1.0.0" check="false"></dubbo:reference>

</beans>

applicationContext-mvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util.xsd">

    <!-- dispatcherServlet截获所有URL请求 -->
    <mvc:default-servlet-handler/>

    <!-- spring mvc 扫描包下的controller -->
    <context:component-scan base-package="com.bjpowernode.p2p.web"/>

    <!-- 配置注解驱动 -->
    <mvc:annotation-driven/>

    <!-- 配置视图解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/loan/**"/>
            <mvc:exclude-mapping path="/loan/loan"/>
            <mvc:exclude-mapping path="/loan/loanInfo"/>
            <mvc:exclude-mapping path="/loan/checkPhone"/>
            <mvc:exclude-mapping path="/loan/checkCaptcha"/>
            <mvc:exclude-mapping path="/loan/register"/>
            <mvc:exclude-mapping path="/loan/login"/>
            <mvc:exclude-mapping path="/loan/loadStat"/>
            <bean class="com.bjpowernode.p2p.interceptor.UserInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

</beans>

config.properties

realNameAppkey=58c30b7829c1c34eb248109
realNameUrl=https://way.jd.com/youhuoBeijing/test

log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="info">
    <!--先定义所有的appender-->
    <appenders>
        <!--这个输出控制台的配置-->
        <Console name="Console" target="SYSTEM_OUT">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="ACCEPT"/>
            <!--这个都知道是输出日志的格式-->
            <PatternLayout pattern="[p2p] %d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
        </Console>
        <!--这个会打印出所有的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFile" fileName="/opt/tomcat_licaihost/logs/app.log"
                     filePattern="/opt/tomcat_licaihost/logs/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
            <PatternLayout pattern="[p2p] %d{yyyy-MM-dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
            <SizeBasedTriggeringPolicy size="300MB"/>
        </RollingFile>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入appender，appender才会生效-->
    <loggers>
        <!--建立一个默认的root的logger-->
        <root level="info">
            <appender-ref ref="Console"/>
            <appender-ref ref="RollingFile"/>
        </root>
    </loggers>
</configuration>

webapp目录
在这里插入图片描述
web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         id="WebApp_ID" version="3.0">
    <!-- 应用名 -->
    <display-name>p2p</display-name>
    <!-- 字符过滤器，字符编码UTF-8 -->
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!-- Spring mvc分发servlet -->
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/index</url-pattern>
    </servlet-mapping>
    <!-- 欢迎页，默认进入index controller -->
    <welcome-file-list>
        <welcome-file>index</welcome-file>
    </welcome-file-list>
</web-app>

完整的链接参考：
我的下载
已上传文件：
记录一下曾经写过的P2P金融项目-理财端（PC端）纯代码(续-服务消费者工程)
在这里插入图片描述

武侠㿝卄清

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
记录一下曾经写过的P2P金融项目-理财端（PC端）纯代码(续-服务消费者工程)

pom文件：<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> &l
复制链接

扫一扫

专栏目录