环境

src/main/java/com/izouma/immall/repo/BackUserRepo.java

@@ -0,0 +1,19 @@
+package com.izouma.immall.repo;
+
+import com.izouma.immall.domain.BackUser;
+import com.izouma.immall.domain.User;
+import com.izouma.immall.security.Authority;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+
+import java.util.List;
+
+public interface BackUserRepo extends JpaRepository<BackUser, Long>, JpaSpecificationExecutor<User> {
+    BackUser findByUsername(String username);
+
+    List<BackUser> findAllByAuthoritiesContains(Authority authority);
+
+//    BackUser findByOpenId(String openId);
+
+    BackUser findByPhone(String phone);
+}

src/main/java/com/izouma/immall/security/JwtBackUser.java

@@ -0,0 +1,82 @@
+package com.izouma.immall.security;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.izouma.immall.domain.BackUser;
+import com.izouma.immall.domain.User;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+
+import java.time.ZoneId;
+import java.util.Collection;
+import java.util.Date;
+
+/**
+ * Created by stephan on 20.03.16.
+ */
+public class JwtBackUser implements UserDetails {
+
+    private static final long serialVersionUID = 5803985158027956021L;
+
+    private final Collection<? extends GrantedAuthority> authorities;
+    private final Date                                   lastPasswordResetDate;
+    private BackUser user;
+
+    public JwtBackUser(BackUser user, Collection<? extends GrantedAuthority> authorities) {
+        this.authorities = authorities;
+        this.lastPasswordResetDate = Date.from(user.getCreatedAt().atZone(ZoneId.systemDefault()).toInstant());
+        this.user = user;
+    }
+
+    @JsonIgnore
+    public Long getId() {
+        return user.getId();
+    }
+
+    @Override
+    public String getUsername() {
+        return user.getUsername();
+    }
+
+    @JsonIgnore
+    @Override
+    public boolean isAccountNonExpired() {
+        return true;
+    }
+
+    @JsonIgnore
+    @Override
+    public boolean isAccountNonLocked() {
+        return true;
+    }
+
+    @JsonIgnore
+    @Override
+    public boolean isCredentialsNonExpired() {
+        return true;
+    }
+
+    @JsonIgnore
+    @Override
+    public String getPassword() {
+        return user.getPassword();
+    }
+
+    @Override
+    public Collection<? extends GrantedAuthority> getAuthorities() {
+        return authorities;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return user.getEnabled();
+    }
+
+    @JsonIgnore
+    public Date getLastPasswordResetDate() {
+        return lastPasswordResetDate;
+    }
+
+    public BackUser getUser() {
+        return user;
+    }
+}

src/main/java/com/izouma/immall/security/JwtBackUserFactory.java

@@ -0,0 +1,29 @@
+package com.izouma.immall.security;
+
+import com.izouma.immall.domain.BackUser;
+import com.izouma.immall.domain.User;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public final class JwtBackUserFactory {
+
+    private JwtBackUserFactory() {
+    }
+
+    public static JwtBackUser create(BackUser user) {
+        return new JwtBackUser(user, mapToGrantedAuthorities(user.getAuthorities()));
+    }
+
+    private static List<GrantedAuthority> mapToGrantedAuthorities(Set<Authority> authorities) {
+        if (authorities != null) {
+            return authorities.stream()
+                              .map(authority -> new SimpleGrantedAuthority(authority.getName()))
+                              .collect(Collectors.toList());
+        }
+        return null;
+    }
+}

src/main/java/com/izouma/immall/service/BackUserService.java

@@ -0,0 +1,160 @@
+package com.izouma.immall.service;
+
+import cn.binarywang.wx.miniapp.api.WxMaService;
+import cn.binarywang.wx.miniapp.bean.WxMaJscode2SessionResult;
+import cn.binarywang.wx.miniapp.bean.WxMaUserInfo;
+import com.izouma.immall.config.Constants;
+import com.izouma.immall.domain.BackUser;
+import com.izouma.immall.domain.User;
+import com.izouma.immall.exception.BusinessException;
+import com.izouma.immall.repo.BackUserRepo;
+import com.izouma.immall.repo.UserRepo;
+import com.izouma.immall.security.Authority;
+import com.izouma.immall.service.sms.SmsService;
+import com.izouma.immall.service.storage.StorageService;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import me.chanjar.weixin.common.error.WxErrorException;
+import me.chanjar.weixin.mp.api.WxMpService;
+import me.chanjar.weixin.mp.bean.result.WxMpOAuth2AccessToken;
+import me.chanjar.weixin.mp.bean.result.WxMpUser;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.PostConstruct;
+import java.text.SimpleDateFormat;
+import java.util.*;
+
+@Service
+@Slf4j
+@AllArgsConstructor
+public class BackUserService {
+    private BackUserRepo backUserRepo;
+    private WxMaService wxMaService;
+    private WxMpService wxMpService;
+    private SmsService smsService;
+    private StorageService storageService;
+
+    public BackUser loginByPhone(String phone) {
+        return backUserRepo.findByPhone(phone);
+    }
+
+/*    public User loginMp(String code) throws WxErrorException {
+        WxMpOAuth2AccessToken accessToken = wxMpService.oauth2getAccessToken(code);
+        WxMpUser wxMpUser = wxMpService.oauth2getUserInfo(accessToken, null);
+        User user = userRepo.findByOpenId(wxMpUser.getOpenId());
+        if (user == null) {
+            user = User.builder()
+                       .username(UUID.randomUUID().toString())
+                       .nickname(wxMpUser.getNickname())
+                       .avatar(wxMpUser.getHeadImgUrl())
+                       .sex(wxMpUser.getSexDesc())
+                       .country(wxMpUser.getCountry())
+                       .province(wxMpUser.getProvince())
+                       .city(wxMpUser.getCity())
+                       .openId(wxMpUser.getOpenId())
+                       .language(wxMpUser.getLanguage())
+                       .enabled(true)
+                       .authorities(Collections.singleton(Authority.builder().name("ROLE_USER").build()))
+                       .build();
+            userRepo.save(user);
+        }
+        return user;
+    }
+
+    public User loginMa(String code) {
+        try {
+            WxMaJscode2SessionResult result = wxMaService.jsCode2SessionInfo(code);
+            String openId = result.getOpenid();
+            String sessionKey = result.getSessionKey();
+            User userInfo = userRepo.findByOpenId(openId);
+            if (userInfo != null) {
+                return userInfo;
+            }
+            userInfo = User.builder()
+                           .username(UUID.randomUUID().toString())
+                           .nickname("用户" + RandomStringUtils.randomAlphabetic(6))
+                           .openId(openId)
+                           .avatar(Constants.DEFAULT_AVATAR)
+                           .enabled(true)
+                           .authorities(Collections.singleton(Authority.builder().name("ROLE_USER").build()))
+                           .build();
+            userInfo = userRepo.save(userInfo);
+            return userInfo;
+        } catch (WxErrorException e) {
+            e.printStackTrace();
+        }
+        throw new BusinessException("登录失败");
+    }
+
+    public User getMaUserInfo(String sessionKey, String rawData, String signature,
+                              String encryptedData, String iv) {
+        // 用户信息校验
+        if (!wxMaService.getUserService().checkUserInfo(sessionKey, rawData, signature)) {
+            throw new BusinessException("获取用户信息失败");
+        }
+
+        // 解密用户信息
+        WxMaUserInfo wxUserInfo = wxMaService.getUserService().getUserInfo(sessionKey, encryptedData, iv);
+        User user = userRepo.findByOpenId(wxUserInfo.getOpenId());
+
+        String avatarUrl = Constants.DEFAULT_AVATAR;
+        try {
+            String path = "image/avatar/" +
+                    new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss").format(new Date()) +
+                    RandomStringUtils.randomAlphabetic(8) +
+                    ".jpg";
+            avatarUrl = storageService.uploadFromUrl(wxUserInfo.getAvatarUrl(), path);
+        } catch (Exception e) {
+            log.error("获取头像失败", e);
+        }
+
+        if (user == null) {
+
+            user = User.builder()
+                       .username(UUID.randomUUID().toString())
+                       .nickname(wxUserInfo.getNickName())
+                       .openId(wxUserInfo.getOpenId())
+                       .avatar(avatarUrl)
+                       .sex(wxUserInfo.getGender())
+                       .country(wxUserInfo.getCountry())
+                       .province(wxUserInfo.getProvince())
+                       .city(wxUserInfo.getCity())
+                       .enabled(true)
+                       .authorities(Collections.singleton(Authority.builder().name("ROLE_USER").build()))
+                       .build();
+            user = userRepo.save(user);
+
+        } else {
+            user.setAvatar(avatarUrl);
+            user.setNickname(wxUserInfo.getNickName());
+            user.setSex(wxUserInfo.getGender());
+            user.setCountry(wxUserInfo.getCountry());
+            user.setProvince(wxUserInfo.getProvince());
+            user.setCity(wxUserInfo.getCity());
+            user = userRepo.save(user);
+        }
+
+        return user;
+    }*/
+
+    @PostConstruct
+    public void init() {
+        BackUser root = backUserRepo.findByUsername("root");
+        if (root == null) {
+            Set<Authority> authorities = new HashSet<>();
+            authorities.add(new Authority(Authority.NAMES.ROLE_ADMIN.name()));
+            authorities.add(new Authority(Authority.NAMES.ROLE_USER.name()));
+            root = BackUser.builder()
+                       .nickname("管理员")
+                       .username("root")
+                       .password(new BCryptPasswordEncoder().encode("123456"))
+                       .avatar(Constants.DEFAULT_AVATAR)
+                       .enabled(true)
+                       .authorities(authorities)
+                       .build();
+            backUserRepo.save(root);
+        }
+    }
+}

src/main/java/com/izouma/immall/web/BackUserController.java

@@ -0,0 +1,84 @@
+package com.izouma.immall.web;
+
+import com.izouma.immall.domain.BackUser;
+import com.izouma.immall.domain.User;
+import com.izouma.immall.dto.PageQuery;
+import com.izouma.immall.exception.BusinessException;
+import com.izouma.immall.repo.BackUserRepo;
+import com.izouma.immall.repo.UserRepo;
+import com.izouma.immall.security.Authority;
+import com.izouma.immall.service.BackUserService;
+import com.izouma.immall.service.UserService;
+import com.izouma.immall.utils.ObjUtils;
+import com.izouma.immall.utils.SecurityUtils;
+import com.izouma.immall.utils.excel.ExcelUtils;
+import io.swagger.annotations.ApiOperation;
+import lombok.AllArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.web.bind.annotation.*;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
+
+@AllArgsConstructor
+@RestController
+@RequestMapping("/back/user")
+public class BackUserController extends BaseController {
+    private BackUserRepo backUserRepo;
+    private BackUserService backUserService;
+
+    @PostMapping("/back/register")
+    public BackUser register(@RequestParam String username,
+                         @RequestParam String password) {
+        BackUser user = BackUser.builder()
+                        .username(username)
+                        .nickname(username)
+                        .password(new BCryptPasswordEncoder().encode(password))
+                        .enabled(true)
+                        .authorities(Collections.singleton(new Authority(Authority.NAMES.ROLE_USER.name())))
+                        .build();
+        return backUserRepo.save(user);
+    }
+
+    @PreAuthorize("hasRole('ADMIN')")
+    @PostMapping("/back/save")
+    public BackUser save(@RequestBody BackUser user) {
+        if (user.getId() != null) {
+            BackUser orig = backUserRepo.findById(user.getId()).orElseThrow(new BusinessException("无记录"));
+            ObjUtils.merge(orig, user);
+            return backUserRepo.save(orig);
+        }
+        return backUserRepo.save(user);
+    }
+
+    @GetMapping("/back/my")
+    public BackUser my() {
+        return backUserRepo.findById(SecurityUtils.getAuthenticatedUser().getId()).orElseThrow(new BusinessException("用户不存在"));
+    }
+
+    @PreAuthorize("hasRole('ADMIN')")
+    @GetMapping("/back/all")
+    public Page<User> all(PageQuery pageQuery) {
+        return backUserRepo.findAll(toSpecification(pageQuery, User.class), toPageRequest(pageQuery));
+    }
+
+    @PreAuthorize("hasRole('ADMIN')")
+    @GetMapping("/back/get/{id}")
+    public BackUser get(@PathVariable Long id) {
+        return backUserRepo.findById(id).orElseThrow(new BusinessException("无记录"));
+    }
+
+    @GetMapping("/back/excel")
+    @ResponseBody
+    public void excel(HttpServletResponse response, PageQuery pageQuery) throws IOException {
+        List<User> data = all(pageQuery).getContent();
+        ExcelUtils.export(response, data);
+    }
+
+
+
+}