温馨提醒：因本店业务繁忙，请需要提供安装服务的买家提前与本店客服联络在购买。如买家购买之后才需要提供安装服务，本店可能暂不解决！谢谢合作！！小白勿拍。
商城后端体验地址:
http://res.boyaokj.cn/admin 账号密码请联络客服
微信小程序前端体验：
微信中搜索：潍院集中营
微信小程序商城带完整版java后端   后端技术选型  springMVC + mybatis +mysql数据库   可直接使用
技术选型
1 后台使用技术
o 1.1 springframework4.3.7.RELEASE
o 1.2 mybatis3.4.1
o 1.3 shiro1.3.2
o 1.4 servlet3.1.0
o 1.5 druid1.0.28
o 1.6 slf4j1.7.19
o 1.7 fastjson1.2.30
o 1.8 poi3.15
o 1.9 velocity1.7
o 1.10 quartz2.2.3
o 1.11 mysql5.1.39
o 1.12 swagger2.4
o 1.13 j2cache2.3.22-release
2 前台使用技术
o 2.1 Vue2.5.1
o 2.2 iview
o 2.3 layer3.0.3
o 2.4 jquery2.2.4
o 2.5 bootstrap3.3.7
o 2.6 jqgrid5.1.1
o 2.7 ztree3.5.26
o 2.8 froala_editor1.2.2
项目结构
platform-wechat-mall
--platform-admin 后端管理
--platform-api 微信小程序商城api接口
--platform-common 公共板块
--platform-framework 系统WEB合并
--platform-gen 代码生成
--platform-schedule 定时任务
--platform-shop 商城后端管理
--wx-mall 微信小程序商城
--platform-vue 微信公众号商城(待开发)
自动代码生成结构
AutoCode
├─menu.sql                      创立菜单的sql
│
└─main
├─java                     生成的java代码
│    └─com
│       └─platform
│            ├─controller
│            ├─dao
│            ├─entity
│            └─service
│                └─impl
└─webapp                   生成的页面文件
├─js
│  └─shop
└─WEB-INF
└─page
└─shop
实现功能
一：会员管理
o a 会员管理
o b 会员等级
o c 收货地址管理
o d 会员优惠劵
o e 会员收藏
o f 会员足迹
o g 搜索历史
o h 购物车
二：商城配置
o a 区域配置
o b 商品属性种类
o c 品牌制造商
o d 商品规格
o e 订单管理
o f 商品类型
o g 渠道管理
o h 商品问答
o i 反馈
o j 关键词
三：商品编辑
o a 所有商品
o b 客户评论
o c 产品设置
o d 商品规格
o e 商品回收站
四：推广管理
o a 广告列表
o b 广告位置
o c 优惠劵管理
o d 专题管理
o e 专题分类
五：订单管理
o a 所有订单管理
六：系统管理
o a 管理员列表
o b 角色管理
o c 菜单管理
o d SQL监控
o e 定时任务
o f 参数管理
o g 代码生成器
o h 系统日志
o i 文件上传
o j 通用字典表
六：短信服务平台
o a 配置短信平台账户信息
o b 向外提供发送短信接口：
http://域名:端口/api/sendSms?mobile=13000000000,15209831990&content=发送的短信内容
安全起见，需配置有效IP地址。platform.properties -> sms.validIp

微信小程序 java设置cookie登录

wx.request()发起的每次请求对于服务器来说都是不同的会话  这样导致后续请求都相当于未登录的状态。

app.js

globalData: {

url: ‘http://127.0.0.1:8080’,

cookie: “”,
},

后台
@PostMapping(“sessionId”)

@ResponseBody`
public String sessionId( HttpServletRequest request){
		String sessionId=request.getSession().getId();
		return sessionId;
	}

返回给前台

前台在请求的回调中给全局的参数cookie赋值
 onLoad: function(options) {
    wx.request({
      url: url,
      method: 'post',
      success(res) {
        app.globalData.cookie = 'JSESSIONID=' + res.data
        console.log(app.globalData.cookie)
      }
    })
  },

然后在每次请求request的header中添加
 header: {
               ....,
               'cookie': getApp().globalData.cookie
          },

一、登录流程图
二、微信小程序端
doLogin:function(callback = () =>{}){
let that = this;
wx.login({
  success:function(loginRes){
    if(loginRes){
      //获取用户信息
      wx.getUserInfo({
        withCredentials:true,//非必填  默认为true
        success:function(infoRes){
          console.log(infoRes,'>>>');
          //请求服务端的登录接口
          wx.request({
            url: api.loginUrl,
            data:{
              code:loginRes.code,//临时登录凭证
              rawData:infoRes.rawData,//用户非敏感信息
              signature:infoRes.signature,//签名
              encrypteData:infoRes.encryptedData,//用户敏感信息
              iv:infoRes.iv//解密算法的向量
            },
            success:function(res){
              console.log('login success');
              res = res.data;
              if(res.result==0){
                that.globalData.userInfo = res.userInfo;
                wx.setStorageSync('userInfo',JSON.stringify(res.userInfo));
                wx.setStorageSync('loginFlag',res.skey);
                console.log("skey="+res.skey);
                callback();
              }else{
                that.showInfo('res.errmsg');
              }
            },
            fail:function(error){
              //调用服务端登录接口失败
             // that.showInfo('调用接口失败');
              console.log(error);
            }
          });
        }
      });
    }else{

    }
  }
});
}
微信小程序端发起登录请求，携带的参数主要有：
    code:loginRes.code,//临时登录凭证
    rawData:infoRes.rawData,//用户非敏感信息
    signature:infoRes.signature,//签名
    encrypteData:infoRes.encryptedData,//用户敏感信息
    iv:infoRes.iv//解密算法的向量
需要的数据主要有：
result、userInfo和skey
result用来判断是否登录成功，userInfo是用户的一些信息，保存在缓存中，不用每次都从后台获取，skey是用户登录态标识，也放在缓存中，如果skey存在就直接登录，维护用户的登录状态，具有时效性
三、Java后台
@ResponseBody
@RequestMapping("/login")
public Map<String,Object> doLogin(Model model,
                                  @RequestParam(value = "code",required = false) String code,
                                  @RequestParam(value = "rawData",required = false) String rawData,
                                  @RequestParam(value = "signature",required = false) String signature,
                                  @RequestParam(value = "encrypteData",required = false) String encrypteData,
                                  @RequestParam(value = "iv",required = false) String iv){
    log.info( "Start get SessionKey" );


    Map<String,Object> map = new HashMap<String, Object>(  );
    System.out.println("用户非敏感信息"+rawData);

    JSONObject rawDataJson = JSON.parseObject( rawData );

    System.out.println("签名"+signature);
    JSONObject SessionKeyOpenId = getSessionKeyOrOpenId( code );
    System.out.println("post请求获取的SessionAndopenId="+SessionKeyOpenId);

    String openid = SessionKeyOpenId.getString("openid" );

    String sessionKey = SessionKeyOpenId.getString( "session_key" );

    System.out.println("openid="+openid+",session_key="+sessionKey);

    User user = userService.findByOpenid( openid );
    //uuid生成唯一key
    String skey = UUID.randomUUID().toString();
    if(user==null){
        //入库
        String nickName = rawDataJson.getString( "nickName" );
        String avatarUrl = rawDataJson.getString( "avatarUrl" );
        String gender  = rawDataJson.getString( "gender" );
        String city = rawDataJson.getString( "city" );
        String country = rawDataJson.getString( "country" );
        String province = rawDataJson.getString( "province" );


        user = new User();
        user.setUid( openid );
        user.setCreateTime( new Date(  ) );
        user.setSessionkey( sessionKey );
        user.setUbalance( 0 );
        user.setSkey( skey );
        user.setUaddress( country+" "+province+" "+city );
        user.setUavatar( avatarUrl );
        user.setUgender( Integer.parseInt( gender ) );
        user.setUname( nickName );
        user.setUpdateTime( new Date(  ) );

        userService.insert( user );
    }else {
        //已存在
        log.info( "用户openid已存在,不需要插入" );
    }
    //根据openid查询skey是否存在
    String skey_redis = (String) redisTemplate.opsForValue().get( openid );
    if(StringUtils.isNotBlank( skey_redis )){
        //存在 删除 skey 重新生成skey 将skey返回
        redisTemplate.delete( skey_redis );

    }
        //  缓存一份新的
        JSONObject sessionObj = new JSONObject(  );
        sessionObj.put( "openId",openid );
        sessionObj.put( "sessionKey",sessionKey );
        redisTemplate.opsForValue().set( skey,sessionObj.toJSONString() );
        redisTemplate.opsForValue().set( openid,skey );

        //把新的sessionKey和oppenid返回给小程序
        map.put( "skey",skey );



    map.put( "result","0" );



    JSONObject userInfo = getUserInfo( encrypteData, sessionKey, iv );
    System.out.println("根据解密算法获取的userInfo="+userInfo);
    userInfo.put( "balance",user.getUbalance() );
    map.put( "userInfo",userInfo );

    return map;
}
获取openid和sessionKey方法
public static JSONObject getSessionKeyOrOpenId(String code){
    //微信端登录code
    String wxCode = code;
    String requestUrl = "https://api.weixin.qq.com/sns/jscode2session";
    Map<String,String> requestUrlParam = new HashMap<String, String>(  );
    requestUrlParam.put( "appid","你的小程序appId" );//小程序appId
    requestUrlParam.put( "secret","你的小程序appSecret" );
    requestUrlParam.put( "js_code",wxCode );//小程序端返回的code
    requestUrlParam.put( "grant_type","authorization_code" );//默认参数

    //发送post请求读取调用微信接口获取openid用户唯一标识
    JSONObject jsonObject = JSON.parseObject( UrlUtil.sendPost( requestUrl,requestUrlParam ));
    return jsonObject;
}
解密用户敏感数据获取用户信息
public static JSONObject getUserInfo(String encryptedData,String sessionKey,String iv){
    // 被加密的数据
    byte[] dataByte = Base64.decode(encryptedData);
    // 加密秘钥
    byte[] keyByte = Base64.decode(sessionKey);
    // 偏移量
    byte[] ivByte = Base64.decode(iv);
    try {
        // 如果密钥不足16位，那么就补足.  这个if 中的内容很重要
        int base = 16;
        if (keyByte.length % base != 0) {
            int groups = keyByte.length / base + (keyByte.length % base != 0 ? 1 : 0);
            byte[] temp = new byte[groups * base];
            Arrays.fill(temp, (byte) 0);
            System.arraycopy(keyByte, 0, temp, 0, keyByte.length);
            keyByte = temp;
        }
        // 初始化
        Security.addProvider(new BouncyCastleProvider());
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding","BC");
        SecretKeySpec spec = new SecretKeySpec(keyByte, "AES");
        AlgorithmParameters parameters = AlgorithmParameters.getInstance("AES");
        parameters.init(new IvParameterSpec(ivByte));
        cipher.init( Cipher.DECRYPT_MODE, spec, parameters);// 初始化
        byte[] resultByte = cipher.doFinal(dataByte);
        if (null != resultByte && resultByte.length > 0) {
            String result = new String(resultByte, "UTF-8");
            return JSON.parseObject(result);
        }
    } catch (NoSuchAlgorithmException e) {
        log.error(e.getMessage(), e);
    } catch (NoSuchPaddingException e) {
        log.error(e.getMessage(), e);
    } catch (InvalidParameterSpecException e) {
        log.error(e.getMessage(), e);
    } catch (IllegalBlockSizeException e) {
        log.error(e.getMessage(), e);
    } catch (BadPaddingException e) {
        log.error(e.getMessage(), e);
    } catch (UnsupportedEncodingException e) {
        log.error(e.getMessage(), e);
    } catch (InvalidKeyException e) {
        log.error(e.getMessage(), e);
    } catch (InvalidAlgorithmParameterException e) {
        log.error(e.getMessage(), e);
    } catch (NoSuchProviderException e) {
        log.error(e.getMessage(), e);
    }
    return null;
}

四、流程
1.小程序端发起请求并携带主要参数
2.java后台接到/login请求后，根据code去调用微信接口获取用户唯一标识openid和sessionKey
3.根据openid查询mysql数据库，判断该用户是否存在，如果不存在将用户非敏感信息和其他初始化数据存入到数据库中，如果已存在，不操作
4.根据openid查询redis数据库，判断openid对应的skey是否存在，如果存在则删除原来老的skey以及对应的openid和sessionKey
5.通过uuid生成唯一的skey，用openid做键，skey做值，存入到redis中
6.然后把skey做键，openid和sessionKey的json串做值也重新存入到redis中
7.根据解密算法，参数有encryptedData、sessionKey和iv，获取用户信息userInfo,如果userInfo字段不满足需要，可通过userInfo.put( "balance",user.getUbalance() );添加所需要的字段和值
8.将微信小程序需要的数据封装到map中，返回给小程序端
map.put( "skey",skey );

map.put( "result","0" );

map.put( "userInfo",userInfo ); 

return map;
更多博客内容详见我的博客 Wang's Blog

微信小程序java后台解码获取信息

由于小程序开发多个地方都需要使用到解码获取信息的需求，但由于本人从事java的开发然后去官网下载的sdk中竟然没有java的。哎-_-。所以准备写一篇关于java解码的blog吧。


  
一、我们解码前需要获取到几个小程序前端传过来的数据 

  登录凭证code：调用wx.login()可以获得； 

  秘钥iv和需要解码的encryptedData字符串：这个根据自己项目的需求定了，比如：获取openid和unionid可以在 wx.getUserInfo()中获得iv和encryptedData。 

  如果获取微信群ID：则通过wx.getShareInfo()获得iv和encryptedData。 

  微信小程序前端这里就不做详细的分析了。
  
  
二 、 java后端的实现




/**
     * 获取微信群ID（Gid）
     * data:2018/1/24
     * @return
     * @throws Exception 
     */
    public String wxGetGroupGid() throws Exception{

        String code=request.getParameter("code");接受小程序传过来的登录凭证code，
        String iv=request.getParameter("iv");
        String encryptedData=request.getParameter("encryptedData");
        String OPENID_URL = "https://api.weixin.qq.com/sns/jscode2session?appid=APPID&secret"
                + "=SECRET&js_code=JSCODE&grant_type=authorization_code";// 获取openid的地址
        String url = OPENID_URL.replace("APPID", Pkcs7Encoder.APPID)
                .replace("SECRET", Pkcs7Encoder.APPSECRET)
                .replace("JSCODE", code);
        JSONObject jsonObject = null;
        //向微信后台发起请求的url 
        jsonObject = Pkcs7Encoder.doGetStr(url);// 调取Get提交方法
        String session_key = jsonObject.getString("session_key");
        String result = Pkcs7Encoder.decrypt(encryptedData, session_key, iv,
                "UTF-8");

        JSONObject userInfoJSON = JSONObject.fromObject(result);
        String openGid=userInfoJSON.getString("openGId");
        System.out.println(openGid);
        String JData="{\"openGid\":\""+openGid+"\"}";
        //response.getWriter().write(openGid);
        Struts2Utils.renderJsonNoDown(response, JData); 
        return null;
    }

解码的帮助类

public class Pkcs7Encoder {
     public final static String APPID = "***";   //小程序的APPID
      public final static   String APPSECRET = "***"; //小程序的appsecret
     public final static String grant_type = "authorization_code";//授权（必填）
      // 算法名称
    static  final String KEY_ALGORITHM = "AES";
    // 加解密算法/模式/填充方式
    static  final String algorithmStr = "AES/CBC/PKCS7Padding";
    private static Key key;
    private static Cipher cipher;
    boolean isInited = false;

    //默认对称解密算法初始向量 iv
    static byte[] iv = { 0x30, 0x31, 0x30, 0x32, 0x30, 0x33, 0x30, 0x34, 0x30, 0x35, 0x30, 0x36, 0x30, 0x37, 0x30, 0x38 };


    public static String decrypt(String encryptedData, String sessionKey, String iv, String encodingFormat)
            throws Exception {
            // 被加密的数据
            byte[] dataByte = Base64.decode(encryptedData);
            // 加密秘钥
            byte[] keyByte = Base64.decode(sessionKey);
            // 偏移量
            byte[] ivByte = Base64.decode(iv);
            try {
            // 如果密钥不足16位，那么就补足. 这个if 中的内容很重要
            int base = 16;
            if (keyByte.length % base != 0) {
            int groups = keyByte.length / base + (keyByte.length % base != 0 ? 1 : 0);
            byte[] temp = new byte[groups * base];
            Arrays.fill(temp, (byte) 0);
            System.arraycopy(keyByte, 0, temp, 0, keyByte.length);
            keyByte = temp;
            }
            // 初始化
            Security.addProvider(new BouncyCastleProvider());
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");
            SecretKeySpec spec = new SecretKeySpec(keyByte, "AES");
            AlgorithmParameters parameters = AlgorithmParameters.getInstance("AES");
            parameters.init(new IvParameterSpec(ivByte));
            cipher.init(Cipher.DECRYPT_MODE, spec, parameters);// 初始化
            byte[] resultByte = cipher.doFinal(dataByte);
            if (null != resultByte && resultByte.length > 0) {
            String result = new String(resultByte, "UTF-8");
            return JSONObject.fromObject(result).toString();
            }
            }catch (Exception e) {
                e.printStackTrace();
            }
            return null;
    }
    /**
     * 返回openid,unionid
     * @param url
     * @return
     */
    public static JSONObject doGetStr(String url){

        DefaultHttpClient httpClient = new DefaultHttpClient();

        HttpGet httpGet = new HttpGet(url);

        JSONObject jsonObject = null;

        try {
            HttpResponse response = httpClient.execute(httpGet);

            HttpEntity entity = response.getEntity();   //接受结果
            if(entity != null){
                String result = EntityUtils.toString(entity,"UTF-8");
                jsonObject = JSONObject.fromObject(result);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return jsonObject;
    }

    public static void init(byte[] keyBytes) {

        // 如果密钥不足16位，那么就补足.  这个if 中的内容很重要
        int base = 16;
        if (keyBytes.length % base != 0) {
            int groups = keyBytes.length / base + (keyBytes.length % base != 0 ? 1 : 0);
            byte[] temp = new byte[groups * base];
            Arrays.fill(temp, (byte) 0);
            System.arraycopy(keyBytes, 0, temp, 0, keyBytes.length);
            keyBytes = temp;
        }
        // 初始化
        Security.addProvider(new BouncyCastleProvider());
        // 转化成JAVA的密钥格式
        key = new SecretKeySpec(keyBytes, KEY_ALGORITHM);
        try {
            // 初始化cipher
            cipher = Cipher.getInstance(algorithmStr, "BC");
        } catch (NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchProviderException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    /**
     * 加密方法
     *      --使用默认iv时
     * @param content
     *            要加密的字符串
     * @param keyBytes
     *            加密密钥
     * @return
     */
    public static byte[] encrypt(byte[] content, byte[] keyBytes) {
        byte[] encryptedText =  encryptOfDiyIV(content,keyBytes,iv);
        return encryptedText;
    }


    /**
     * 解密方法
     *      --使用默认iv时
     * @param encryptedData
     *            要解密的字符串
     * @param keyBytes
     *            解密密钥
     * @return
     */
    public static byte[] decrypt(byte[] encryptedData, byte[] keyBytes) {
        byte[] encryptedText = decryptOfDiyIV(encryptedData,keyBytes,iv);
        return encryptedText;
    }
    /**
     * 加密方法
     *      ---自定义对称解密算法初始向量 iv
     * @param content
     *              要加密的字符串
     * @param keyBytes
     *              加密密钥
     * @param ivs
     *         自定义对称解密算法初始向量 iv
     * @return 加密的结果
     */
    public static byte[] encryptOfDiyIV(byte[] content, byte[] keyBytes, byte[] ivs) {
        byte[] encryptedText = null;
        init(keyBytes);
        System.out.println("IV：" + new String(ivs));
        try {
            cipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(ivs));
            encryptedText = cipher.doFinal(content);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return encryptedText;
    }
    /**
     * 解密方法
     *
     * @param encryptedData
     *            要解密的字符串
     * @param keyBytes
     *            解密密钥
     * @param ivs
     *         自定义对称解密算法初始向量 iv
     * @return
     */
    public static byte[] decryptOfDiyIV(byte[] encryptedData, byte[] keyBytes,byte[] ivs) {
        byte[] encryptedText = null;
        init(keyBytes);
        System.out.println("IV：" + new String(ivs));
        try {
            cipher.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(ivs));
            encryptedText = cipher.doFinal(encryptedData);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return encryptedText;
    }
    /** 
* 向指定 URL 发送POST方法的请求 
*  
* @param url 发送请求的 URL 
* @param param 请求参数 
* @return 所代表远程资源的响应结果 
*/  
public static String sendPost(String url, Map<String, ?> paramMap) {  
     PrintWriter out = null;  
     BufferedReader in = null;  
     String result = "";  

     String param = "";  
Iterator<String> it = paramMap.keySet().iterator();  

while(it.hasNext()) {  
   String key = it.next();  
   param += key + "=" + paramMap.get(key) + "&";  
}  

     try {  
         URL realUrl = new URL(url);  
         // 打开和URL之间的连接  
         URLConnection conn = realUrl.openConnection();  
         // 设置通用的请求属性  
         conn.setRequestProperty("accept", "*/*");  
         conn.setRequestProperty("connection", "Keep-Alive");  
         conn.setRequestProperty("Accept-Charset", "utf-8");  
         conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");  
         // 发送POST请求必须设置如下两行  
         conn.setDoOutput(true);  
         conn.setDoInput(true);  
         // 获取URLConnection对象对应的输出流  
         out = new PrintWriter(conn.getOutputStream());  
         // 发送请求参数  
         out.print(param);  
         // flush输出流的缓冲  
         out.flush();  
         // 定义BufferedReader输入流来读取URL的响应  
         in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));  
         String line;  
         while ((line = in.readLine()) != null) {  
             result += line;  
         }  
     } catch (Exception e) {  
      e.printStackTrace();
     }  
     //使用finally块来关闭输出流、输入流  
     finally{  
         try{  
             if(out!=null){  
                 out.close();  
             }  
             if(in!=null){  
                 in.close();  
             }  
         }  
         catch(IOException ex){  
             ex.printStackTrace();  
         }  
     }  
     return result;  
 }  

}


  
只要涉及到小程序解码的都是通用的，所以到这里已经完成了。