pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!--自己的父项目-->
<parent>
<groupId>com.spring</groupId>
<artifactId>micr-parent</artifactId>
<version>1.0.0</version>
<relativePath/>
</parent>
<groupId>com.spring</groupId>
<artifactId>spring-dataservice</artifactId>
<version>1.0.0</version>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>com.spring</groupId>
<artifactId>spring-common</artifactId>
<version>1.0.0</version>
</dependency>
<!--dubbo公共项目依赖-->
<dependency>
<groupId>com.spring</groupId>
<artifactId>spring-api</artifactId>
<version>1.0.0</version>
</dependency>
<!--dubbo起步依赖-->
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-spring-boot-starter</artifactId>
</dependency>
<!--zookeeper起步依赖-->
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-dependencies-zookeeper</artifactId>
<type>pom</type>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
application.yml
#服务名称
spring:
application:
name: spring-dataservice
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/ylb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
username: root
password: 1234
#设置mybatis
mybatis:
mapper-locations: classpath:/mappers/**/*.xml
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
map-underscore-to-camel-case: true
#Dubbo配置
dubbo:
registry:
address: zookeeper://localhost:2181
scan:
base-packages: com.spring.dataservice.service
provider:
timeout: 50000
retries: 0
#密码的盐
#盐(Salt) 在密码学中,是指通过在密码任意固定位置插入特定的字符串,让散列后的结果和使用原始密码的散列结果不相符,这种过程称之为“加盐”。
ylb:
config:
password-salt: fiwsyhrf9wejroi2huio3y4234operw3resources.mappers.BidInfoMapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.spring.dataservice.mapper.BidInfoMapper">
<resultMap id="BaseResultMap" type="com.spring.api.model.BidInfo">
<id column="id" jdbcType="INTEGER" property="id" />
<result column="prod_id" jdbcType="INTEGER" property="prodId" />
<result column="uid" jdbcType="INTEGER" property="uid" />
<result column="bid_money" jdbcType="DECIMAL" property="bidMoney" />
<result column="bid_time" jdbcType="TIMESTAMP" property="bidTime" />
<result column="bid_status" jdbcType="INTEGER" property="bidStatus" />
</resultMap>
<sql id="Base_Column_List">
id, prod_id, uid, bid_money, bid_time, bid_status
</sql>
<!--累计成交金额-->
<select id="selectSumBidMoney" resultType="java.math.BigDecimal">
select sum(bid_money) as sumBidMoney from b_bid_info
</select>
<select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from b_bid_info
where id = #{id,jdbcType=INTEGER}
</select>
<!--某个产品的投资记录-->
<select id="selectByProductId" resultType="com.spring.api.pojo.BidInfoProduct">
SELECT
bid.id,
CONCAT( SUBSTRING( u.phone FROM 1 FOR 3 ), "******", SUBSTRING( u.phone FROM 10 FOR 2 ) ) AS phone,
DATE_FORMAT( bid.bid_time, "%Y-%m-%d %H:%i:%s" ) AS bidTime,
bid.bid_money AS bidMoney
FROM
b_bid_info bid
JOIN u_user u ON bid.uid = u.id
WHERE
bid.prod_id = #{productId}
ORDER BY
bid.bid_time DESC
LIMIT #{offset},#{rows}
</select>
<!--某个产品的投资记录-->
<select id="selectByProdId" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM
b_bid_info
WHERE
prod_id = #{productId} AND bid_status = 1
ORDER BY id
</select>
<delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
delete from b_bid_info
where id = #{id,jdbcType=INTEGER}
</delete>
<insert id="insert" parameterType="com.spring.api.model.BidInfo">
insert into b_bid_info (id, prod_id, uid,
bid_money, bid_time, bid_status
)
values (#{id,jdbcType=INTEGER}, #{prodId,jdbcType=INTEGER}, #{uid,jdbcType=INTEGER},
#{bidMoney,jdbcType=DECIMAL}, #{bidTime,jdbcType=TIMESTAMP}, #{bidStatus,jdbcType=INTEGER}
)
</insert>
<insert id="insertSelective" parameterType="com.spring.api.model.BidInfo">
insert into b_bid_info
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="id != null">
id,
</if>
<if test="prodId != null">
prod_id,
</if>
<if test="uid != null">
uid,
</if>
<if test="bidMoney != null">
bid_money,
</if>
<if test="bidTime != null">
bid_time,
</if>
<if test="bidStatus != null">
bid_status,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="id != null">
#{id,jdbcType=INTEGER},
</if>
<if test="prodId != null">
#{prodId,jdbcType=INTEGER},
</if>
<if test="uid != null">
#{uid,jdbcType=INTEGER},
</if>
<if test="bidMoney != null">
#{bidMoney,jdbcType=DECIMAL},
</if>
<if test="bidTime != null">
#{bidTime,jdbcType=TIMESTAMP},
</if>
<if test="bidStatus != null">
#{bidStatus,jdbcType=INTEGER},
</if>
</trim>
</insert>
<update id="updateByPrimaryKeySelective" parameterType="com.spring.api.model.BidInfo">
update b_bid_info
<set>
<if test="prodId != null">
prod_id = #{prodId,jdbcType=INTEGER},
</if>
<if test="uid != null">
uid = #{uid,jdbcType=INTEGER},
</if>
<if test="bidMoney != null">
bid_money = #{bidMoney,jdbcType=DECIMAL},
</if>
<if test="bidTime != null">
bid_time = #{bidTime,jdbcType=TIMESTAMP},
</if>
<if test="bidStatus != null">
bid_status = #{bidStatus,jdbcType=INTEGER},
</if>
</set>
where id = #{id,jdbcType=INTEGER}
</update>
<update id="updateByPrimaryKey" parameterType="com.spring.api.model.BidInfo">
update b_bid_info
set prod_id = #{prodId,jdbcType=INTEGER},
uid = #{uid,jdbcType=INTEGER},
bid_money = #{bidMoney,jdbcType=DECIMAL},
bid_time = #{bidTime,jdbcType=TIMESTAMP},
bid_status = #{bidStatus,jdbcType=INTEGER}
where id = #{id,jdbcType=INTEGER}
</update>
</mapper>resources.mappers.FinanceAccountMapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.spring.dataservice.mapper.FinanceAccountMapper">
<resultMap id="BaseResultMap" type="com.spring.api.model.FinanceAccount">
<id column="id" jdbcType="INTEGER" property="id" />
<result column="uid" jdbcType="INTEGER" property="uid" />
<result column="available_money" jdbcType="DECIMAL" property="availableMoney" />
</resultMap>
<sql id="Base_Column_List">
id, uid, available_money
</sql>
<select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from u_finance_account
where id = #{id,jdbcType=INTEGER}
</select>
<!--/*给uid的记录上锁*/-->
<select id="selectByUidForUpdate" resultMap="BaseResultMap">
select <include refid="Base_Column_List" />
from u_finance_account
where uid = #{uid}
for update
</select>
<delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
delete from u_finance_account
where id = #{id,jdbcType=INTEGER}
</delete>
<insert id="insert" parameterType="com.spring.api.model.FinanceAccount">
insert into u_finance_account (id, uid, available_money
)
values (#{id,jdbcType=INTEGER}, #{uid,jdbcType=INTEGER}, #{availableMoney,jdbcType=DECIMAL}
)
</insert>
<insert id="insertSelective" parameterType="com.spring.api.model.FinanceAccount">
insert into u_finance_account
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="id != null">
id,
</if>
<if test="uid != null">
uid,
</if>
<if test="availableMoney != null">
available_money,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="id != null">
#{id,jdbcType=INTEGER},
</if>
<if test="uid != null">
#{uid,jdbcType=INTEGER},
</if>
<if test="availableMoney != null">
#{availableMoney,jdbcType=DECIMAL},
</if>
</trim>
</insert>
<update id="updateByPrimaryKeySelective" parameterType="com.spring.api.model.FinanceAccount">
update u_finance_account
<set>
<if test="uid != null">
uid = #{uid,jdbcType=INTEGER},
</if>
<if test="availableMoney != null">
available_money = #{availableMoney,jdbcType=DECIMAL},
</if>
</set>
where id = #{id,jdbcType=INTEGER}
</update>
<update id="updateByPrimaryKey" parameterType="com.spring.api.model.FinanceAccount">
update u_finance_account
set uid = #{uid,jdbcType=INTEGER},
available_money = #{availableMoney,jdbcType=DECIMAL}
where id = #{id,jdbcType=INTEGER}
</update>
<!--更新资金-->
<update id="updateAvailableMoneyByInvest">
update u_finance_account set available_money = available_money - #{money}
where uid = #{uid} and ( available_money - #{money} >=0 )
</update>
</mapper>resources.mappers.IncomeRecordMapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.spring.dataservice.mapper.IncomeRecordMapper">
<resultMap id="BaseResultMap" type="com.spring.api.model.IncomeRecord">
<id column="id" jdbcType="INTEGER" property="id" />
<result column="uid" jdbcType="INTEGER" property="uid" />
<result column="prod_id" jdbcType="INTEGER" property="prodId" />
<result column="bid_id" jdbcType="INTEGER" property="bidId" />
<result column="bid_money" jdbcType="DECIMAL" property="bidMoney" />
<result column="income_date" jdbcType="DATE" property="incomeDate" />
<result column="income_money" jdbcType="DECIMAL" property="incomeMoney" />
<result column="income_status" jdbcType="INTEGER" property="incomeStatus" />
</resultMap>
<sql id="Base_Column_List">
id, uid, prod_id, bid_id, bid_money, income_date, income_money, income_status
</sql>
<select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from b_income_record
where id = #{id,jdbcType=INTEGER}
</select>
<delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
delete from b_income_record
where id = #{id,jdbcType=INTEGER}
</delete>
<insert id="insert" parameterType="com.spring.api.model.IncomeRecord">
insert into b_income_record (id, uid, prod_id,
bid_id, bid_money, income_date,
income_money, income_status)
values (#{id,jdbcType=INTEGER}, #{uid,jdbcType=INTEGER}, #{prodId,jdbcType=INTEGER},
#{bidId,jdbcType=INTEGER}, #{bidMoney,jdbcType=DECIMAL}, #{incomeDate,jdbcType=DATE},
#{incomeMoney,jdbcType=DECIMAL}, #{incomeStatus,jdbcType=INTEGER})
</insert>
<insert id="insertSelective" parameterType="com.spring.api.model.IncomeRecord">
insert into b_income_record
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="id != null">
id,
</if>
<if test="uid != null">
uid,
</if>
<if test="prodId != null">
prod_id,
</if>
<if test="bidId != null">
bid_id,
</if>
<if test="bidMoney != null">
bid_money,
</if>
<if test="incomeDate != null">
income_date,
</if>
<if test="incomeMoney != null">
income_money,
</if>
<if test="incomeStatus != null">
income_status,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="id != null">
#{id,jdbcType=INTEGER},
</if>
<if test="uid != null">
#{uid,jdbcType=INTEGER},
</if>
<if test="prodId != null">
#{prodId,jdbcType=INTEGER},
</if>
<if test="bidId != null">
#{bidId,jdbcType=INTEGER},
</if>
<if test="bidMoney != null">
#{bidMoney,jdbcType=DECIMAL},
</if>
<if test="incomeDate != null">
#{incomeDate,jdbcType=DATE},
</if>
<if test="incomeMoney != null">
#{incomeMoney,jdbcType=DECIMAL},
</if>
<if test="incomeStatus != null">
#{incomeStatus,jdbcType=INTEGER},
</if>
</trim>
</insert>
<update id="updateByPrimaryKeySelective" parameterType="com.spring.api.model.IncomeRecord">
update b_income_record
<set>
<if test="uid != null">
uid = #{uid,jdbcType=INTEGER},
</if>
<if test="prodId != null">
prod_id = #{prodId,jdbcType=INTEGER},
</if>
<if test="bidId != null">
bid_id = #{bidId,jdbcType=INTEGER},
</if>
<if test="bidMoney != null">
bid_money = #{bidMoney,jdbcType=DECIMAL},
</if>
<if test="incomeDate != null">
income_date = #{incomeDate,jdbcType=DATE},
</if>
<if test="incomeMoney != null">
income_money = #{incomeMoney,jdbcType=DECIMAL},
</if>
<if test="incomeStatus != null">
income_status = #{incomeStatus,jdbcType=INTEGER},
</if>
</set>
where id = #{id,jdbcType=INTEGER}
</update>
<update id="updateByPrimaryKey" parameterType="com.spring.api.model.IncomeRecord">
update b_income_record
set uid = #{uid,jdbcType=INTEGER},
prod_id = #{prodId,jdbcType=INTEGER},
bid_id = #{bidId,jdbcType=INTEGER},
bid_money = #{bidMoney,jdbcType=DECIMAL},
income_date = #{incomeDate,jdbcType=DATE},
income_money = #{incomeMoney,jdbcType=DECIMAL},
income_status = #{incomeStatus,jdbcType=INTEGER}
where id = #{id,jdbcType=INTEGER}
</update>
</mapper>resources.mappers.ProductInfoMapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.spring.dataservice.mapper.ProductInfoMapper">
<resultMap id="BaseResultMap" type="com.spring.api.model.ProductInfo">
<id column="id" jdbcType="INTEGER" property="id" />
<result column="product_name" jdbcType="VARCHAR" property="productName" />
<result column="rate" jdbcType="DECIMAL" property="rate" />
<result column="cycle" jdbcType="INTEGER" property="cycle" />
<result column="release_time" jdbcType="DATE" property="releaseTime" />
<result column="product_type" jdbcType="INTEGER" property="productType" />
<result column="product_no" jdbcType="VARCHAR" property="productNo" />
<result column="product_money" jdbcType="DECIMAL" property="productMoney" />
<result column="left_product_money" jdbcType="DECIMAL" property="leftProductMoney" />
<result column="bid_min_limit" jdbcType="DECIMAL" property="bidMinLimit" />
<result column="bid_max_limit" jdbcType="DECIMAL" property="bidMaxLimit" />
<result column="product_status" jdbcType="INTEGER" property="productStatus" />
<result column="product_full_time" jdbcType="TIMESTAMP" property="productFullTime" />
<result column="product_desc" jdbcType="VARCHAR" property="productDesc" />
</resultMap>
<sql id="Base_Column_List">
id, product_name, rate, cycle, release_time, product_type, product_no, product_money,
left_product_money, bid_min_limit, bid_max_limit, product_status, product_full_time,
product_desc
</sql>
<!--利率平均值-->
<select id="selectAvgRate" resultType="java.math.BigDecimal">
select round(avg(rate),2) as avgRate from b_product_info
</select>
<!--按产品类型分页查询-->
<select id="selectByTypeLimit" resultMap="BaseResultMap">
select <include refid="Base_Column_List" />
from b_product_info
where product_type = #{ptype}
order by release_time desc
limit #{offset},#{rows}
</select>
<!--某个产品类型的记录总数-->
<select id="selectCountByType" resultType="java.lang.Integer">
select count(id) as nums from b_product_info where product_type = #{ptype}
</select>
<select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from b_product_info
where id = #{id,jdbcType=INTEGER}
</select>
<!--满标的理财列表-->
<select id="selectFullTimeProducts" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List" />
FROM
b_product_info
WHERE
product_status = 1
AND product_full_time >= #{beginTime} AND product_full_time < #{endTime}
order by id
</select>
<delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
delete from b_product_info
where id = #{id,jdbcType=INTEGER}
</delete>
<insert id="insert" parameterType="com.spring.api.model.ProductInfo">
insert into b_product_info (id, product_name, rate,
cycle, release_time, product_type,
product_no, product_money, left_product_money,
bid_min_limit, bid_max_limit, product_status,
product_full_time, product_desc)
values (#{id,jdbcType=INTEGER}, #{productName,jdbcType=VARCHAR}, #{rate,jdbcType=DECIMAL},
#{cycle,jdbcType=INTEGER}, #{releaseTime,jdbcType=DATE}, #{productType,jdbcType=INTEGER},
#{productNo,jdbcType=VARCHAR}, #{productMoney,jdbcType=DECIMAL}, #{leftProductMoney,jdbcType=DECIMAL},
#{bidMinLimit,jdbcType=DECIMAL}, #{bidMaxLimit,jdbcType=DECIMAL}, #{productStatus,jdbcType=INTEGER},
#{productFullTime,jdbcType=TIMESTAMP}, #{productDesc,jdbcType=VARCHAR})
</insert>
<insert id="insertSelective" parameterType="com.spring.api.model.ProductInfo">
insert into b_product_info
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="id != null">
id,
</if>
<if test="productName != null">
product_name,
</if>
<if test="rate != null">
rate,
</if>
<if test="cycle != null">
cycle,
</if>
<if test="releaseTime != null">
release_time,
</if>
<if test="productType != null">
product_type,
</if>
<if test="productNo != null">
product_no,
</if>
<if test="productMoney != null">
product_money,
</if>
<if test="leftProductMoney != null">
left_product_money,
</if>
<if test="bidMinLimit != null">
bid_min_limit,
</if>
<if test="bidMaxLimit != null">
bid_max_limit,
</if>
<if test="productStatus != null">
product_status,
</if>
<if test="productFullTime != null">
product_full_time,
</if>
<if test="productDesc != null">
product_desc,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="id != null">
#{id,jdbcType=INTEGER},
</if>
<if test="productName != null">
#{productName,jdbcType=VARCHAR},
</if>
<if test="rate != null">
#{rate,jdbcType=DECIMAL},
</if>
<if test="cycle != null">
#{cycle,jdbcType=INTEGER},
</if>
<if test="releaseTime != null">
#{releaseTime,jdbcType=DATE},
</if>
<if test="productType != null">
#{productType,jdbcType=INTEGER},
</if>
<if test="productNo != null">
#{productNo,jdbcType=VARCHAR},
</if>
<if test="productMoney != null">
#{productMoney,jdbcType=DECIMAL},
</if>
<if test="leftProductMoney != null">
#{leftProductMoney,jdbcType=DECIMAL},
</if>
<if test="bidMinLimit != null">
#{bidMinLimit,jdbcType=DECIMAL},
</if>
<if test="bidMaxLimit != null">
#{bidMaxLimit,jdbcType=DECIMAL},
</if>
<if test="productStatus != null">
#{productStatus,jdbcType=INTEGER},
</if>
<if test="productFullTime != null">
#{productFullTime,jdbcType=TIMESTAMP},
</if>
<if test="productDesc != null">
#{productDesc,jdbcType=VARCHAR},
</if>
</trim>
</insert>
<update id="updateByPrimaryKeySelective" parameterType="com.spring.api.model.ProductInfo">
update b_product_info
<set>
<if test="productName != null">
product_name = #{productName,jdbcType=VARCHAR},
</if>
<if test="rate != null">
rate = #{rate,jdbcType=DECIMAL},
</if>
<if test="cycle != null">
cycle = #{cycle,jdbcType=INTEGER},
</if>
<if test="releaseTime != null">
release_time = #{releaseTime,jdbcType=DATE},
</if>
<if test="productType != null">
product_type = #{productType,jdbcType=INTEGER},
</if>
<if test="productNo != null">
product_no = #{productNo,jdbcType=VARCHAR},
</if>
<if test="productMoney != null">
product_money = #{productMoney,jdbcType=DECIMAL},
</if>
<if test="leftProductMoney != null">
left_product_money = #{leftProductMoney,jdbcType=DECIMAL},
</if>
<if test="bidMinLimit != null">
bid_min_limit = #{bidMinLimit,jdbcType=DECIMAL},
</if>
<if test="bidMaxLimit != null">
bid_max_limit = #{bidMaxLimit,jdbcType=DECIMAL},
</if>
<if test="productStatus != null">
product_status = #{productStatus,jdbcType=INTEGER},
</if>
<if test="productFullTime != null">
product_full_time = #{productFullTime,jdbcType=TIMESTAMP},
</if>
<if test="productDesc != null">
product_desc = #{productDesc,jdbcType=VARCHAR},
</if>
</set>
where id = #{id,jdbcType=INTEGER}
</update>
<update id="updateByPrimaryKey" parameterType="com.spring.api.model.ProductInfo">
update b_product_info
set product_name = #{productName,jdbcType=VARCHAR},
rate = #{rate,jdbcType=DECIMAL},
cycle = #{cycle,jdbcType=INTEGER},
release_time = #{releaseTime,jdbcType=DATE},
product_type = #{productType,jdbcType=INTEGER},
product_no = #{productNo,jdbcType=VARCHAR},
product_money = #{productMoney,jdbcType=DECIMAL},
left_product_money = #{leftProductMoney,jdbcType=DECIMAL},
bid_min_limit = #{bidMinLimit,jdbcType=DECIMAL},
bid_max_limit = #{bidMaxLimit,jdbcType=DECIMAL},
product_status = #{productStatus,jdbcType=INTEGER},
product_full_time = #{productFullTime,jdbcType=TIMESTAMP},
product_desc = #{productDesc,jdbcType=VARCHAR}
where id = #{id,jdbcType=INTEGER}
</update>
<!--扣除产品剩余可投资金额-->
<update id="updateLeftProductMoney">
update b_product_info set left_product_money = left_product_money - #{money}
where id = #{id} and ( left_product_money - #{money} >=0 )
</update>
<!--*更新产品为满标-->
<update id="updateSelled">
update b_product_info set product_status = 1 , product_full_time = now()
where id = #{id}
</update>
<!--更新状态-->
<update id="updateStatus">
update b_product_info set product_status = #{newStatus} where id = #{id}
</update>
</mapper>resources.mappers.RechargeRecordMapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.spring.dataservice.mapper.RechargeRecordMapper">
<resultMap id="BaseResultMap" type="com.spring.api.model.RechargeRecord">
<id column="id" jdbcType="INTEGER" property="id" />
<result column="uid" jdbcType="INTEGER" property="uid" />
<result column="recharge_no" jdbcType="VARCHAR" property="rechargeNo" />
<result column="recharge_status" jdbcType="INTEGER" property="rechargeStatus" />
<result column="recharge_money" jdbcType="DECIMAL" property="rechargeMoney" />
<result column="recharge_time" jdbcType="TIMESTAMP" property="rechargeTime" />
<result column="recharge_desc" jdbcType="VARCHAR" property="rechargeDesc" />
<result column="channel" jdbcType="VARCHAR" property="channel" />
</resultMap>
<sql id="Base_Column_List">
id, uid, recharge_no, recharge_status, recharge_money, recharge_time, recharge_desc,
channel
</sql>
<!--按userId查询充值记录-->
<select id="selectByUid" resultMap="BaseResultMap">
select <include refid="Base_Column_List" />
from b_recharge_record
where uid= #{uid}
order by recharge_time desc
limit #{offset},#{rows}
</select>
<select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from b_recharge_record
where id = #{id,jdbcType=INTEGER}
</select>
<delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
delete from b_recharge_record
where id = #{id,jdbcType=INTEGER}
</delete>
<insert id="insert" parameterType="com.spring.api.model.RechargeRecord">
insert into b_recharge_record (id, uid, recharge_no,
recharge_status, recharge_money, recharge_time,
recharge_desc, channel)
values (#{id,jdbcType=INTEGER}, #{uid,jdbcType=INTEGER}, #{rechargeNo,jdbcType=VARCHAR},
#{rechargeStatus,jdbcType=INTEGER}, #{rechargeMoney,jdbcType=DECIMAL}, #{rechargeTime,jdbcType=TIMESTAMP},
#{rechargeDesc,jdbcType=VARCHAR}, #{channel,jdbcType=VARCHAR})
</insert>
<insert id="insertSelective" parameterType="com.spring.api.model.RechargeRecord">
insert into b_recharge_record
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="id != null">
id,
</if>
<if test="uid != null">
uid,
</if>
<if test="rechargeNo != null">
recharge_no,
</if>
<if test="rechargeStatus != null">
recharge_status,
</if>
<if test="rechargeMoney != null">
recharge_money,
</if>
<if test="rechargeTime != null">
recharge_time,
</if>
<if test="rechargeDesc != null">
recharge_desc,
</if>
<if test="channel != null">
channel,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="id != null">
#{id,jdbcType=INTEGER},
</if>
<if test="uid != null">
#{uid,jdbcType=INTEGER},
</if>
<if test="rechargeNo != null">
#{rechargeNo,jdbcType=VARCHAR},
</if>
<if test="rechargeStatus != null">
#{rechargeStatus,jdbcType=INTEGER},
</if>
<if test="rechargeMoney != null">
#{rechargeMoney,jdbcType=DECIMAL},
</if>
<if test="rechargeTime != null">
#{rechargeTime,jdbcType=TIMESTAMP},
</if>
<if test="rechargeDesc != null">
#{rechargeDesc,jdbcType=VARCHAR},
</if>
<if test="channel != null">
#{channel,jdbcType=VARCHAR},
</if>
</trim>
</insert>
<update id="updateByPrimaryKeySelective" parameterType="com.spring.api.model.RechargeRecord">
update b_recharge_record
<set>
<if test="uid != null">
uid = #{uid,jdbcType=INTEGER},
</if>
<if test="rechargeNo != null">
recharge_no = #{rechargeNo,jdbcType=VARCHAR},
</if>
<if test="rechargeStatus != null">
recharge_status = #{rechargeStatus,jdbcType=INTEGER},
</if>
<if test="rechargeMoney != null">
recharge_money = #{rechargeMoney,jdbcType=DECIMAL},
</if>
<if test="rechargeTime != null">
recharge_time = #{rechargeTime,jdbcType=TIMESTAMP},
</if>
<if test="rechargeDesc != null">
recharge_desc = #{rechargeDesc,jdbcType=VARCHAR},
</if>
<if test="channel != null">
channel = #{channel,jdbcType=VARCHAR},
</if>
</set>
where id = #{id,jdbcType=INTEGER}
</update>
<update id="updateByPrimaryKey" parameterType="com.spring.api.model.RechargeRecord">
update b_recharge_record
set uid = #{uid,jdbcType=INTEGER},
recharge_no = #{rechargeNo,jdbcType=VARCHAR},
recharge_status = #{rechargeStatus,jdbcType=INTEGER},
recharge_money = #{rechargeMoney,jdbcType=DECIMAL},
recharge_time = #{rechargeTime,jdbcType=TIMESTAMP},
recharge_desc = #{rechargeDesc,jdbcType=VARCHAR},
channel = #{channel,jdbcType=VARCHAR}
where id = #{id,jdbcType=INTEGER}
</update>
</mapper>resources.mappers.UserMapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.spring.dataservice.mapper.UserMapper">
<resultMap id="BaseResultMap" type="com.spring.api.model.User">
<id column="id" jdbcType="INTEGER" property="id" />
<result column="phone" jdbcType="VARCHAR" property="phone" />
<result column="login_password" jdbcType="VARCHAR" property="loginPassword" />
<result column="name" jdbcType="VARCHAR" property="name" />
<result column="id_card" jdbcType="VARCHAR" property="idCard" />
<result column="add_time" jdbcType="TIMESTAMP" property="addTime" />
<result column="last_login_time" jdbcType="TIMESTAMP" property="lastLoginTime" />
<result column="header_image" jdbcType="VARCHAR" property="headerImage" />
</resultMap>
<resultMap id="UserAccountMap" type="com.spring.api.pojo.UserAccountInfo">
<id column="id" jdbcType="INTEGER" property="id" />
<result column="phone" jdbcType="VARCHAR" property="phone" />
<result column="login_password" jdbcType="VARCHAR" property="loginPassword" />
<result column="name" jdbcType="VARCHAR" property="name" />
<result column="id_card" jdbcType="VARCHAR" property="idCard" />
<result column="add_time" jdbcType="TIMESTAMP" property="addTime" />
<result column="last_login_time" jdbcType="TIMESTAMP" property="lastLoginTime" />
<result column="header_image" jdbcType="VARCHAR" property="headerImage" />
<result column="available_money" jdbcType="DECIMAL" property="availableMoney" />
</resultMap>
<sql id="Base_Column_List">
id, phone, login_password, name, id_card, add_time, last_login_time, header_image
</sql>
<!--注册用户数量-->
<select id="selectCountUser" resultType="java.lang.Integer">
select count(id) as ct from u_user
</select>
<!--使用手机号查询用户-->
<select id="selectByPhone" resultMap="BaseResultMap">
select <include refid="Base_Column_List"></include>
from u_user
where phone = #{phone}
</select>
<!--添加记录，获取主键值-->
<insert id="insertReturnPrimaryKey">
insert into u_user(phone, login_password,add_time)
values(#{phone},#{loginPassword},#{addTime})
<selectKey keyColumn="newId" keyProperty="id" resultType="int" order="AFTER">
select LAST_INSERT_ID() as newId
</selectKey>
</insert>
<!--登录-->
<select id="selectLogin" resultMap="BaseResultMap">
select <include refid="Base_Column_List"></include>
from u_user
where phone = #{phone} and login_password = #{loginPassword}
</select>
<select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from u_user
where id = #{id,jdbcType=INTEGER}
</select>
<!--查询用户信息-->
<select id="selectUserAccountById" resultMap="UserAccountMap">
SELECT
u.*,
a.available_money
FROM
u_user u
JOIN u_finance_account a ON u.id = a.uid
WHERE
u.id = #{uid}
</select>
<!--更新实名认证信息-->
<update id="updateRealname">
update u_user set name=#{name} , id_card = #{idCard} where phone = #{phone}
</update>
<delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
delete from u_user
where id = #{id,jdbcType=INTEGER}
</delete>
<insert id="insert" parameterType="com.spring.api.model.User">
insert into u_user (id, phone, login_password,
name, id_card, add_time,
last_login_time, header_image)
values (#{id,jdbcType=INTEGER}, #{phone,jdbcType=VARCHAR}, #{loginPassword,jdbcType=VARCHAR},
#{name,jdbcType=VARCHAR}, #{idCard,jdbcType=VARCHAR}, #{addTime,jdbcType=TIMESTAMP},
#{lastLoginTime,jdbcType=TIMESTAMP}, #{headerImage,jdbcType=VARCHAR})
</insert>
<insert id="insertSelective" parameterType="com.spring.api.model.User">
insert into u_user
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="id != null">
id,
</if>
<if test="phone != null">
phone,
</if>
<if test="loginPassword != null">
login_password,
</if>
<if test="name != null">
name,
</if>
<if test="idCard != null">
id_card,
</if>
<if test="addTime != null">
add_time,
</if>
<if test="lastLoginTime != null">
last_login_time,
</if>
<if test="headerImage != null">
header_image,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="id != null">
#{id,jdbcType=INTEGER},
</if>
<if test="phone != null">
#{phone,jdbcType=VARCHAR},
</if>
<if test="loginPassword != null">
#{loginPassword,jdbcType=VARCHAR},
</if>
<if test="name != null">
#{name,jdbcType=VARCHAR},
</if>
<if test="idCard != null">
#{idCard,jdbcType=VARCHAR},
</if>
<if test="addTime != null">
#{addTime,jdbcType=TIMESTAMP},
</if>
<if test="lastLoginTime != null">
#{lastLoginTime,jdbcType=TIMESTAMP},
</if>
<if test="headerImage != null">
#{headerImage,jdbcType=VARCHAR},
</if>
</trim>
</insert>
<update id="updateByPrimaryKeySelective" parameterType="com.spring.api.model.User">
update u_user
<set>
<if test="phone != null">
phone = #{phone,jdbcType=VARCHAR},
</if>
<if test="loginPassword != null">
login_password = #{loginPassword,jdbcType=VARCHAR},
</if>
<if test="name != null">
name = #{name,jdbcType=VARCHAR},
</if>
<if test="idCard != null">
id_card = #{idCard,jdbcType=VARCHAR},
</if>
<if test="addTime != null">
add_time = #{addTime,jdbcType=TIMESTAMP},
</if>
<if test="lastLoginTime != null">
last_login_time = #{lastLoginTime,jdbcType=TIMESTAMP},
</if>
<if test="headerImage != null">
header_image = #{headerImage,jdbcType=VARCHAR},
</if>
</set>
where id = #{id,jdbcType=INTEGER}
</update>
<update id="updateByPrimaryKey" parameterType="com.spring.api.model.User">
update u_user
set phone = #{phone,jdbcType=VARCHAR},
login_password = #{loginPassword,jdbcType=VARCHAR},
name = #{name,jdbcType=VARCHAR},
id_card = #{idCard,jdbcType=VARCHAR},
add_time = #{addTime,jdbcType=TIMESTAMP},
last_login_time = #{lastLoginTime,jdbcType=TIMESTAMP},
header_image = #{headerImage,jdbcType=VARCHAR}
where id = #{id,jdbcType=INTEGER}
</update>
</mapper>DataserviceApplication
package com.spring.dataservice;
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//启动Dubbo服务
@EnableDubbo
//Mapper扫描表
@MapperScan(basePackages = "com.spring.dataservice.mapper")
@SpringBootApplication
public class DataserviceApplication {
public static void main(String[] args) {
SpringApplication.run(DataserviceApplication.class, args);
}
}
IncomeServiceImpl
package com.spring.dataservice.service;
import com.spring.api.model.BidInfo;
import com.spring.api.model.IncomeRecord;
import com.spring.api.model.ProductInfo;
import com.spring.api.service.IncomeService;
import com.spring.common.constants.YLBConstant;
import com.spring.dataservice.mapper.BidInfoMapper;
import com.spring.dataservice.mapper.IncomeRecordMapper;
import com.spring.dataservice.mapper.ProductInfoMapper;
import org.apache.commons.lang3.time.DateUtils;
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
/**
* Package:com.spring.dataservice.service
*/
@DubboService(interfaceClass = IncomeService.class,version = "1.0")
public class IncomeServiceImpl implements IncomeService {
@Resource
private ProductInfoMapper productInfoMapper;
@Resource
private BidInfoMapper bidInfoMapper;
@Resource
private IncomeRecordMapper incomeMapper;
/*收益计划*/
@Transactional(rollbackFor = Exception.class)
@Override
public synchronized void generateIncomePlan() {
//1.获取要处理的理财产品记录
Date currentDate = new Date();
Date beginTime = DateUtils.truncate(DateUtils.addDays(currentDate, -1), Calendar.DATE);;
Date endTime = DateUtils.truncate(currentDate, Calendar.DATE);;
List<ProductInfo> productInfoList = productInfoMapper.selectFullTimeProducts(beginTime,endTime);
//2.查询每个理财产品的多个投资记录
int rows = 0 ;
BigDecimal income = null;
BigDecimal dayRate = null;
BigDecimal cycle = null; //周期
Date incomeDate = null;//到期时间
for(ProductInfo product:productInfoList){
//日利率
dayRate = product.getRate().divide(new BigDecimal("360"),10, RoundingMode.HALF_UP)
.divide(new BigDecimal("100"),10,RoundingMode.HALF_UP);
//产品类型不同，周期不同 天 ，月
if( product.getProductType() == YLBConstant.PRODUCT_TYPE_XINSHOUBAO){ //天为单位
cycle = new BigDecimal(product.getCycle());
incomeDate = DateUtils.addDays(product.getProductFullTime(),(1+product.getCycle()));
} else {
cycle = new BigDecimal(product.getCycle() * 30);
incomeDate = DateUtils.addDays(product.getProductFullTime(),(1+ product.getCycle() * 30 ));
}
List<BidInfo> bidList = bidInfoMapper.selectByProdId(product.getId());
//3.计算每笔投资的 利息 和 到期时间
for(BidInfo bid : bidList){
//利息 = 本金 * 周期 * 利率
income = bid.getBidMoney().multiply(cycle).multiply(dayRate);
// 创建收益记录
IncomeRecord incomeRecord = new IncomeRecord();
incomeRecord.setBidId(bid.getId());
incomeRecord.setBidMoney(bid.getBidMoney());
incomeRecord.setIncomeDate(incomeDate);
incomeRecord.setIncomeStatus(YLBConstant.INCOME_STATUS_PLAN);
incomeRecord.setProdId(product.getId());
incomeRecord.setIncomeMoney(income);
incomeRecord.setUid(bid.getUid());
incomeMapper.insertSelective(incomeRecord);
}
//更新产品的状态
rows = productInfoMapper.updateStatus(product.getId(),YLBConstant.PRODUCT_STATUS_PLAN);
if(rows < 1 ){
throw new RuntimeException("生成收益计划，更新产品状态为2失败");
}
}
}
}
InvestServiceImpl
package com.spring.dataservice.service;
import com.spring.api.model.BidInfo;
import com.spring.api.model.FinanceAccount;
import com.spring.api.model.ProductInfo;
import com.spring.api.pojo.BidInfoProduct;
import com.spring.api.service.InvestService;
import com.spring.common.constants.YLBConstant;
import com.spring.common.util.CommonUtil;
import com.spring.dataservice.mapper.BidInfoMapper;
import com.spring.dataservice.mapper.FinanceAccountMapper;
import com.spring.dataservice.mapper.ProductInfoMapper;
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* Package:com.spring.dataservice.service
*/
@DubboService(interfaceClass = InvestService.class, version = "1.0")
public class InvestServiceImpl implements InvestService {
@Resource
private BidInfoMapper bidInfoMapper;
@Resource
private FinanceAccountMapper accountMapper;
@Resource
private ProductInfoMapper productInfoMapper;
/**
* 查询某个产品的投资记录
*/
@Override
public List<BidInfoProduct> queryBidListByProductId(Integer productId,
Integer pageNo,
Integer pageSize) {
List<BidInfoProduct> bidList = new ArrayList<>();
if (productId != null && productId > 0) {
pageNo = CommonUtil.defaultPageNo(pageNo);
pageSize = CommonUtil.defaultPageSize(pageSize);
int offset = (pageNo - 1) * pageSize;
bidList = bidInfoMapper.selectByProductId(productId, offset, pageSize);
}
return bidList;
}
/*投资理财产品， int 是投资的结果 ， 1 投资成功*/
@Transactional(rollbackFor = Exception.class)
@Override
public int investProduct(Integer uid, Integer productId, BigDecimal money) {
int result = 0;//默认，参数不正确
int rows = 0;
//1参数检查
if ((uid != null && uid > 0) && (productId != null && productId > 0)
&& (money != null && money.intValue() % 100 == 0 && money.intValue() >= 100)) {
//2.查询账号金额
FinanceAccount account = accountMapper.selectByUidForUpdate(uid);
if (account != null) {
if (CommonUtil.ge(account.getAvailableMoney(), money)) {
//资金满足购买要求
//3.检查产品是否可以购买
ProductInfo productInfo = productInfoMapper.selectByPrimaryKey(productId);
if (productInfo != null
&& productInfo.getProductStatus() == YLBConstant.PRODUCT_STATUS_SELLING) {
if (CommonUtil.ge(productInfo.getLeftProductMoney(), money) &&
CommonUtil.ge(money, productInfo.getBidMinLimit()) &&
CommonUtil.ge(productInfo.getBidMaxLimit(), money)) {
//可以购买了 4. 扣除账号资金
rows = accountMapper.updateAvailableMoneyByInvest(uid, money);
if (rows < 1) {
throw new RuntimeException("投资更新账号资金失败");
}
//5.扣除产品剩余可投资金额
rows = productInfoMapper.updateLeftProductMoney(productId, money);
if (rows < 1) {
throw new RuntimeException("投资更新产品剩余金额失败");
}
//6.创建投资记录
BidInfo bidInfo = new BidInfo();
bidInfo.setBidMoney(money);
bidInfo.setBidStatus(YLBConstant.INVEST_STATUS_SUCC);
bidInfo.setBidTime(new Date());
bidInfo.setProdId(productId);
bidInfo.setUid(uid);
bidInfoMapper.insertSelective(bidInfo);
//7.判断产品是否卖完,更新产品是满标状态
ProductInfo dbProductInfo = productInfoMapper.selectByPrimaryKey(productId);
if( dbProductInfo.getLeftProductMoney().compareTo(new BigDecimal("0")) == 0 ){
rows = productInfoMapper.updateSelled(productId);
if( rows < 1 ){
throw new RuntimeException("投资更新产品满标失败");
}
}
//8.最后这是投资成功
result = 1;
}
} else {
result = 4;//理财产品不存在
}
} else {
result = 3;//资金不足
}
} else {
result = 2;//资金账号不存在
}
}
return result;
}
}
PlatBaseInfoServiceImpl
package com.spring.dataservice.service;
import com.spring.api.pojo.BaseInfo;
import com.spring.api.service.PlatBaseInfoService;
import com.spring.dataservice.mapper.BidInfoMapper;
import com.spring.dataservice.mapper.ProductInfoMapper;
import com.spring.dataservice.mapper.UserMapper;
import org.apache.dubbo.config.annotation.DubboService;
import javax.annotation.Resource;
import java.math.BigDecimal;
/**
* Package:com.spring.dataservice.service
*/
@DubboService(interfaceClass = PlatBaseInfoService.class,version = "1.0")
public class PlatBaseInfoServiceImpl implements PlatBaseInfoService {
//注入Mapper
@Resource
private UserMapper userMapper;
@Resource
private ProductInfoMapper productInfoMapper;
@Resource
private BidInfoMapper bidInfoMapper;
/*平台基本信息*/
@Override
public BaseInfo queryPlatBaseInfo() {
//获取注册人数， 收益率平均值， 累计成交金额
int registerUser = userMapper.selectCountUser();
//收益率平均值
BigDecimal avgRate = productInfoMapper.selectAvgRate();
//累计成交金额
BigDecimal sumBidMoney = bidInfoMapper.selectSumBidMoney();
BaseInfo baseInfo = new BaseInfo(avgRate,sumBidMoney,registerUser);
return baseInfo;
}
}
ProductServiceImpl
package com.spring.dataservice.service;
import com.spring.api.model.ProductInfo;
import com.spring.api.pojo.MultiProduct;
import com.spring.api.service.ProductService;
import com.spring.common.constants.YLBConstant;
import com.spring.common.util.CommonUtil;
import com.spring.dataservice.mapper.ProductInfoMapper;
import org.apache.dubbo.config.annotation.DubboService;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
/**
* Package:com.spring.dataservice.service
*/
@DubboService(interfaceClass = ProductService.class,version = "1.0")
public class ProductServiceImpl implements ProductService {
@Resource
private ProductInfoMapper productInfoMapper;
/*按类型分页查询产品*/
@Override
public List<ProductInfo> queryByTypeLimit(Integer pType, Integer pageNo, Integer pageSize) {
List<ProductInfo> productInfos = new ArrayList<>();
if( pType == 0 || pType == 1 || pType == 2){
pageNo = CommonUtil.defaultPageNo(pageNo);
pageSize = CommonUtil.defaultPageSize(pageSize);
int offset = (pageNo - 1) * pageSize;
productInfos = productInfoMapper.selectByTypeLimit(pType, offset, pageSize);
}
return productInfos;
}
/*某个产品类型的记录总数*/
@Override
public Integer queryRecordNumsByType(Integer pType) {
Integer counts = 0;
if( pType == 0 || pType == 1 || pType == 2){
counts = productInfoMapper.selectCountByType(pType);
}
return counts;
}
/*首页的多个产品数据*/
@Override
public MultiProduct queryIndexPageProducts() {
MultiProduct result = new MultiProduct();
//查询新手宝
List<ProductInfo> xinShouBaoList = productInfoMapper.selectByTypeLimit(
YLBConstant.PRODUCT_TYPE_XINSHOUBAO,0,1);
//查询优选
List<ProductInfo> youXuanList = productInfoMapper.selectByTypeLimit(
YLBConstant.PRODUCT_TYPE_YOUXUAN,0,3 );
//散标
List<ProductInfo> sanBiaoList = productInfoMapper.selectByTypeLimit(
YLBConstant.PRODUCT_TYPE_SANBIAO,0,3 );
result.setXinShouBao(xinShouBaoList);
result.setYouXuan(youXuanList);
result.setSanBiao(sanBiaoList);
return result;
}
/** 根据产品id ，查询产品信息 */
@Override
public ProductInfo queryById(Integer id) {
ProductInfo productInfo = null;
if( id != null && id > 0 ){
productInfo = productInfoMapper.selectByPrimaryKey(id);
}
return productInfo;
}
}
RechargeServiceImpl
package com.spring.dataservice.service;
import com.spring.api.model.RechargeRecord;
import com.spring.api.service.RechargeService;
import com.spring.common.util.CommonUtil;
import com.spring.dataservice.mapper.RechargeRecordMapper;
import org.apache.dubbo.config.annotation.DubboService;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
/**
* Package:com.spring.dataservice.service
*/
@DubboService(interfaceClass = RechargeService.class,version = "1.0")
public class RechargeServiceImpl implements RechargeService {
@Resource
private RechargeRecordMapper rechargeMapper;
/*根据userID查询它的充值记录*/
@Override
public List<RechargeRecord> queryByUid(Integer uid, Integer pageNo, Integer pageSize) {
List<RechargeRecord> records = new ArrayList<>();
if( uid != null && uid > 0 ){
pageNo = CommonUtil.defaultPageNo(pageNo);
pageSize = CommonUtil.defaultPageSize(pageSize);
int offset = (pageNo -1 ) * pageSize;
records = rechargeMapper.selectByUid(uid, offset, pageSize);
}
return records;
}
}
UserServiceImpl
package com.spring.dataservice.service;
import com.spring.api.model.FinanceAccount;
import com.spring.api.model.User;
import com.spring.api.pojo.UserAccountInfo;
import com.spring.api.service.UserService;
import com.spring.common.util.CommonUtil;
import com.spring.dataservice.mapper.FinanceAccountMapper;
import com.spring.dataservice.mapper.UserMapper;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.Date;
/**
* Package:com.spring.dataservice.service
*/
@DubboService(interfaceClass = UserService.class,version = "1.0")
public class UserServiceImpl implements UserService {
@Resource
private UserMapper userMapper;
@Resource
private FinanceAccountMapper financeAccountMapper;
@Value("${ylb.config.password-salt}")
private String passwordSalt;
@Override
public User queryByPhone(String phone) {
User user = null;
if(CommonUtil.checkPhone(phone)){
user = userMapper.selectByPhone(phone);
}
return user;
}
/*用户注册*/
@Transactional(rollbackFor = Exception.class)
@Override
public synchronized int userRegister(String phone, String password) {
int result = 0;//默认参数不正确
if( CommonUtil.checkPhone(phone)
&& (password != null && password.length()==32)){
//判断手机号在库中是否存在
User queryUser = userMapper.selectByPhone(phone);
if(queryUser == null){
//注册密码的md5二次加密。 给原始的密码加盐（salt)
String newPassword = DigestUtils.md5Hex( password + passwordSalt);
//注册u_user
User user = new User();
user.setPhone(phone);
user.setLoginPassword(newPassword);
user.setAddTime(new Date());
userMapper.insertReturnPrimaryKey(user);
//获取主键user.getId()
FinanceAccount account = new FinanceAccount();
account.setUid(user.getId());
account.setAvailableMoney(new BigDecimal("0"));
financeAccountMapper.insertSelective(account);
//成功result = 1
result = 1;
} else {
//手机号存在
result = 2;
}
}
return result;
}
/*登录*/
@Transactional(rollbackFor = Exception.class)
@Override
public User userLogin(String phone, String password) {
User user = null;
if( CommonUtil.checkPhone(phone) && (password != null && password.length() == 32)) {
String newPassword = DigestUtils.md5Hex( password + passwordSalt);
user = userMapper.selectLogin(phone,newPassword);
//更新最后登录时间
if( user != null){
user.setLastLoginTime(new Date());
userMapper.updateByPrimaryKeySelective(user);
}
}
return user;
}
/*更新实名认证信息*/
@Override
public boolean modifyRealname(String phone, String name, String idCard) {
int rows = 0;
if(!StringUtils.isAnyBlank(phone,name,idCard)){
rows = userMapper.updateRealname(phone,name,idCard);
}
return rows > 0 ;
}
/*获取用户和资金信息*/
@Override
public UserAccountInfo queryUserAllInfo(Integer uid) {
UserAccountInfo info = null;
if( uid != null && uid > 0 ) {
info = userMapper.selectUserAccountById(uid);
}
return info ;
}
/*查询用户*/
@Override
public User queryById(Integer uid) {
User user = null;
if( uid != null && uid > 0 ){
user = userMapper.selectByPrimaryKey(uid);
}
return user;
}
}
mapper.BidInfoMapper
package com.spring.dataservice.mapper;
import com.spring.api.model.BidInfo;
import com.spring.api.pojo.BidInfoProduct;
import org.apache.ibatis.annotations.Param;
import java.math.BigDecimal;
import java.util.List;
public interface BidInfoMapper {
/*累计成交金额*/
BigDecimal selectSumBidMoney();
/*某个产品的投资记录*/
List<BidInfoProduct> selectByProductId(@Param("productId") Integer productId,
@Param("offset") int offset,
@Param("rows") Integer rows);
int deleteByPrimaryKey(Integer id);
int insert(BidInfo record);
int insertSelective(BidInfo record);
BidInfo selectByPrimaryKey(Integer id);
int updateByPrimaryKeySelective(BidInfo record);
int updateByPrimaryKey(BidInfo record);
/*某个产品的投资记录*/
List<BidInfo> selectByProdId(@Param("productId") Integer productId);
}mapper.FinanceAccountMapper
package com.spring.dataservice.mapper;
import com.spring.api.model.FinanceAccount;
import org.apache.ibatis.annotations.Param;
import java.math.BigDecimal;
public interface FinanceAccountMapper {
int deleteByPrimaryKey(Integer id);
int insert(FinanceAccount record);
int insertSelective(FinanceAccount record);
FinanceAccount selectByPrimaryKey(Integer id);
int updateByPrimaryKeySelective(FinanceAccount record);
int updateByPrimaryKey(FinanceAccount record);
/*给uid的记录上锁*/
FinanceAccount selectByUidForUpdate(@Param("uid") Integer uid);
/*更新资金*/
int updateAvailableMoneyByInvest(@Param("uid") Integer uid, @Param("money") BigDecimal money);
}mapper.IncomeRecordMapper
package com.spring.dataservice.mapper;
import com.spring.api.model.IncomeRecord;
public interface IncomeRecordMapper {
int deleteByPrimaryKey(Integer id);
int insert(IncomeRecord record);
int insertSelective(IncomeRecord record);
IncomeRecord selectByPrimaryKey(Integer id);
int updateByPrimaryKeySelective(IncomeRecord record);
int updateByPrimaryKey(IncomeRecord record);
}mapper.ProductInfoMapper
package com.spring.dataservice.mapper;
import com.spring.api.model.ProductInfo;
import org.apache.ibatis.annotations.Param;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
public interface ProductInfoMapper {
/*利率平均值*/
BigDecimal selectAvgRate();
/*按产品类型分页查询*/
List<ProductInfo> selectByTypeLimit(@Param("ptype") Integer ptype,
@Param("offset") Integer offset,
@Param("rows") Integer rows);
/*某个产品类型的记录总数*/
Integer selectCountByType(@Param("ptype") Integer pType);
int deleteByPrimaryKey(Integer id);
int insert(ProductInfo record);
int insertSelective(ProductInfo record);
ProductInfo selectByPrimaryKey(Integer id);
int updateByPrimaryKeySelective(ProductInfo record);
int updateByPrimaryKey(ProductInfo record);
/*扣除产品剩余可投资金额*/
int updateLeftProductMoney(@Param("id") Integer productId, @Param("money") BigDecimal money);
/*更新产品为满标*/
int updateSelled(@Param("id") Integer productId);
/*满标的理财列表*/
List<ProductInfo> selectFullTimeProducts(@Param("beginTime") Date beginTime, @Param("endTime") Date endTime);
/*更新状态*/
int updateStatus(@Param("id") Integer id, @Param("newStatus") int newStatus);
}mapper.RechargeRecordMapper
package com.spring.dataservice.mapper;
import com.spring.api.model.RechargeRecord;
import org.apache.ibatis.annotations.Param;
import java.util.List;
public interface RechargeRecordMapper {
int deleteByPrimaryKey(Integer id);
int insert(RechargeRecord record);
int insertSelective(RechargeRecord record);
RechargeRecord selectByPrimaryKey(Integer id);
int updateByPrimaryKeySelective(RechargeRecord record);
int updateByPrimaryKey(RechargeRecord record);
List<RechargeRecord> selectByUid(@Param("uid") Integer uid,
@Param("offset") int offset,
@Param("rows") Integer rows);
}mapper.UserMapper
package com.spring.dataservice.mapper;
import com.spring.api.model.User;
import com.spring.api.pojo.UserAccountInfo;
import org.apache.ibatis.annotations.Param;
public interface UserMapper {
//统计注册人数
int selectCountUser();
/*使用手机号查询用户*/
User selectByPhone(@Param("phone") String phone);
/*添加记录，获取主键值*/
int insertReturnPrimaryKey(User user);
int deleteByPrimaryKey(Integer id);
int insert(User record);
int insertSelective(User record);
User selectByPrimaryKey(Integer id);
int updateByPrimaryKeySelective(User record);
int updateByPrimaryKey(User record);
/*登录*/
User selectLogin(@Param("phone") String phone, @Param("loginPassword") String newPassword);
/*更新实名认证信息*/
int updateRealname(@Param("phone") String phone, @Param("name") String name, @Param("idCard") String idCard);
/*查询用户信息*/
UserAccountInfo selectUserAccountById(@Param("uid") Integer uid);
}