modify account to user

core/pom.xml

@@ -3,7 +3,12 @@
          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">
     <modelVersion>4.0.0</modelVersion>
-
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>2.1.6.RELEASE</version>
+        <relativePath/> <!-- lookup parent from repository -->
+    </parent>
     <groupId>com.mooctest.crowd</groupId>
     <artifactId>core</artifactId>
     <version>1.0-SNAPSHOT</version>
@@ -31,56 +36,53 @@
             <version>1.6.4</version>
         </dependency>
 
-        <!--dubbo-domainservice-api-->
-        <!--dubbo-dependency-->
-        <!-- https://mvnrepository.com/artifact/io.dubbo.springboot/spring-boot-starter-dubbo -->
-        <dependency>
-            <groupId>io.dubbo.springboot</groupId>
-            <artifactId>spring-boot-starter-dubbo</artifactId>
-            <version>1.0.0</version>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.javassist</groupId>
-                    <artifactId>javassist</artifactId>
-                </exclusion>
-                <exclusion>
-                    <groupId>org.slf4j</groupId>
-                    <artifactId>slf4j-log4j12</artifactId>
-                </exclusion>
-            </exclusions>
-        </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
             <version>1.18.6</version>
         </dependency>
+
+
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>18.0</version>
+        </dependency>
+
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-web</artifactId>
-            <version>RELEASE</version>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter</artifactId>
-            <version>2.1.6.RELEASE</version>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <scope>runtime</scope>
         </dependency>
         <dependency>
-            <groupId>javax.persistence</groupId>
-            <artifactId>javax.persistence-api</artifactId>
-            <version>2.2</version>
-            <scope>compile</scope>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
         </dependency>
         <dependency>
-            <groupId>javax.transaction</groupId>
-            <artifactId>javax.transaction-api</artifactId>
-            <version>1.3</version>
-            <scope>compile</scope>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
         </dependency>
+
         <dependency>
-            <groupId>org.springframework.data</groupId>
-            <artifactId>spring-data-commons</artifactId>
-            <version>2.1.9.RELEASE</version>
-            <scope>compile</scope>
+            <groupId>org.hibernate.javax.persistence</groupId>
+            <artifactId>hibernate-jpa-2.1-api</artifactId>
+            <version>1.0.0.Final</version>
         </dependency>
 
     </dependencies>

core/src/main/java/com/mooctest/crowd/domain/Application.java

@@ -4,10 +4,13 @@ import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
 @SpringBootApplication
+//@ComponentScan(basePackages = {"com"})
+//@ComponentScan({"com.mooctest.crowd.domain.controller","com.mooctest.crowd.domain.dao","com.mooctest.crowd.domain.repository",
+//        "com.mooctest.crowd.domain.domainservice","com.mooctest.crowd.domain.domainobject"})
 public class Application
 {
     public static void main( String[] args )
     {
         SpringApplication.run(Application.class,args);
     }
-}
+}

core/src/main/java/com/mooctest/crowd/domain/controller/CommonController.java

@@ -0,0 +1 @@
+package com.mooctest.crowd.domain.controller;

import com.mooctest.crowd.domain.domainobject.User;
import com.mooctest.crowd.domain.domainservice.RegisterDService;
import com.mooctest.crowd.domain.exception.UserNotExistException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;


/**
 * @Author: xuexb
 * @Date: 2019.7.22 16:51
 */
@RestController
public class CommonController {

    @Autowired
    RegisterDService registerDService;

    @RequestMapping(value = "/register/{mobile}/{password}", method = RequestMethod.GET)
    public String hello(@PathVariable("mobile") String mobile, @PathVariable("password") String password) throws UserNotExistException {
        User registerUser = registerDService.register(mobile, password);
        System.out.println(registerUser.toString());
        return registerUser.getMobile();
    }
}

core/src/main/java/com/mooctest/crowd/domain/dao/UserDao.java

@@ -1,21 +1,19 @@
 package com.mooctest.crowd.domain.dao;
 
-import com.mooctest.crowd.domain.model.User;
-import org.springframework.data.repository.CrudRepository;
+import com.mooctest.crowd.domain.model.UserPO;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.repository.PagingAndSortingRepository;
 
 import javax.transaction.Transactional;
 
 @Transactional
-public interface UserDao extends CrudRepository<User,Long> {
+public interface UserDao extends PagingAndSortingRepository<UserPO, Long>, JpaSpecificationExecutor<UserPO> {
 
 //    @Query("SELECT u FROM User u WHERE u.U_MOBILE = :mobile")
 //    User findByMobile(@Param("mobile") String mobile);
 
-    User findByMobile(String mobile);
+    UserPO findByMobile(String mobile);
 
-    @Override
-    long count();
+    UserPO save(UserPO userPo);
 
-    @Override
-    User save(User user);
 }

core/src/main/java/com/mooctest/crowd/domain/domainobject/User.java

@@ -1,8 +1,15 @@
 package com.mooctest.crowd.domain.domainobject;
 
+import com.mooctest.crowd.domain.exception.PasswordErrorException;
+import com.mooctest.crowd.domain.exception.UserNotExistException;
+import com.mooctest.crowd.domain.repository.UserRepo;
+import com.mooctest.crowd.domain.util.EncryptionUtil;
 import lombok.Data;
+import org.springframework.beans.factory.annotation.Autowired;
 
 import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * @author guochao
@@ -19,7 +26,60 @@ public class User {
     private String province;
     private String city;
     private String photoUrl;
-    private String isAvailable;
-    private String isDeleted;
+    private int isAvailable;
+    private int isDeleted;
     private Timestamp createTime;
+
+    @Autowired
+    private UserRepo userRepo = new UserRepo();
+
+    public boolean login(String mobileNum,String password) throws PasswordErrorException, UserNotExistException {
+
+        User user = userRepo.getByMobileNum(mobileNum);
+        if(user!=null){
+            if (user.getPassword().equals(EncryptionUtil.encryptMD5(password))) {
+                return true;
+            }
+            else {
+                throw new PasswordErrorException();
+            }
+        }
+        else{
+            throw new UserNotExistException();
+        }
+
+    }
+
+    public User modifyPassword(String mobileNum,String password,String oldPassword) throws PasswordErrorException, UserNotExistException {
+
+        User user = userRepo.getByMobileNum(mobileNum);
+        if (user.getPassword().equals(EncryptionUtil.encryptMD5(oldPassword))) {
+            user.setPassword(password);
+            User updateUser = userRepo.updateUser(user);
+            return updateUser;
+        }
+        else {
+            throw new PasswordErrorException();
+        }
+    }
+
+    public List<Permission> distributePermission(){
+        List<Permission> permissions = new ArrayList<Permission>();
+        Permission permission = new Permission();
+        permission.setId(1L);
+        permission.setName("PERMISSION_ONE");
+        permission.setResource("RESOURCE_ONE");
+        permission.setOperation("OPERATION_ONE");
+        permissions.add(permission);
+        return permissions;
+    }
+
+    public List<Role> distributeRole() {
+        List<Role> roles = new ArrayList<Role>();
+        Role role = new Role();
+        role.setId(1L);
+        role.setName("GeneralUser");
+        roles.add(role);
+        return roles;
+    }
 }

core/src/main/java/com/mooctest/crowd/domain/domainservice/RegisterDService.java

@@ -1,14 +1,17 @@
 package com.mooctest.crowd.domain.domainservice;
 
-import com.mooctest.crowd.domain.domainobject.Account;
-import com.mooctest.crowd.domain.exception.AccountNotExistException;
+import com.mooctest.crowd.domain.dao.UserDao;
+import com.mooctest.crowd.domain.domainobject.User;
 import com.mooctest.crowd.domain.exception.HttpBadRequestException;
-import com.mooctest.crowd.domain.repository.AccountUTRepo;
+import com.mooctest.crowd.domain.exception.UserNotExistException;
+import com.mooctest.crowd.domain.repository.UserRepo;
+import com.mooctest.crowd.domain.util.EncryptionUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
+import java.sql.Timestamp;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 
@@ -20,35 +23,32 @@ import java.util.Date;
 public class RegisterDService {
 
     @Autowired
-    private AccountUTRepo accountUTRepo;
+    private UserRepo userRepo;
+
+    @Autowired
+    private UserDao userDao;
+
+    private User user = new User();
 
     private Logger LOG = LoggerFactory.getLogger(getClass());
 
-    public Account register(String mobileNum, String password) throws AccountNotExistException {
-//        Account account = null;
-//        try {
-//            account = accountUTRepo.getByMobileNum(cmd.getMobileNum());
-//        } catch (AccountNotExistException e) {
-//            System.out.println("no user ");
-//            Account addAccount = AccountFactory.createAccount();
-//            addAccount.setMobileNum(cmd.getMobileNum());
-//            addAccount.setPassword(cmd.getPassword());
-//            account = accountUTRepo.addAccount(addAccount);
-//            e.printStackTrace();
-//        }
-        if(accountUTRepo.getByMobileNum(mobileNum) == null){
-            System.out.println("no user ");
-//            Account addAccount = AccountFactory.createAccount();
-//            addAccount.setMobileNum(cmd.getMobileNum());
-//            addAccount.setPassword(cmd.getPassword());
-//            return accountUTRepo.addAccount(addAccount);
-        }else{
-            String reason = "注册用户已存在";
-            createLogForRegister(mobileNum, reason);
-            System.out.println("注册用户已存在");
-            throw new HttpBadRequestException("user already exists");
+    public User register(String mobileNum, String password) {
+        try {
+            User user = userRepo.getByMobileNum(mobileNum);
+//            if(user != null){
+                String reason = "注册用户已存在";
+                createLogForRegister(mobileNum, reason);
+                System.out.println("注册用户已存在");
+                throw new HttpBadRequestException("user already exists");
+//            }
+
+        } catch (UserNotExistException e) {
+            user.setMobile(mobileNum);
+            user.setPassword(password);
+            registerUser(user);
+            User saveUser = userRepo.save(user);
+            return saveUser;
         }
-        return null;
     }
 
     private void createLogForRegister(String mobileNum, String reason) {
@@ -57,4 +57,13 @@ public class RegisterDService {
         LOG.error("用户{}注册失败,失败时间：{},失败原因：{}",new Object[]{mobileNum,df.format(date), reason});
     }
 
+    private User registerUser(User user) {
+        user.setIsAvailable(1);
+        user.setIsDeleted(0);
+        user.setPassword(EncryptionUtil.encryptMD5(user.getPassword()));
+        user.setCreateTime(new Timestamp(System.currentTimeMillis()));
+        return user;
+
+    }
+
 }

core/src/main/java/com/mooctest/crowd/domain/exception/UserNotExistException.java

@@ -0,0 +1,8 @@
+package com.mooctest.crowd.domain.exception;
+
+/**
+ * @Author: xuexb
+ * @Date: 2019.7.5 14:36
+ */
+public class UserNotExistException extends BaseException {
+}

core/src/main/java/com/mooctest/crowd/domain/factory/UserFactory.java

@@ -0,0 +1,17 @@
+package com.mooctest.crowd.domain.factory;
+
+import com.mooctest.crowd.domain.domainobject.User;
+import org.springframework.beans.factory.annotation.Autowired;
+
+/**
+ * @Author: xuexb
+ * @Date: 2019.7.5 15:19
+ */
+public class UserFactory {
+
+    @Autowired
+    private static User user;
+    public static User createUser() {
+        return user;
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/model/EvaluationAgency.java

@@ -9,7 +9,7 @@ import java.sql.Timestamp;
  * @date 2019/7/12 1:32
  */
 @Data
-public class EvaluationAgency extends User {
+public class EvaluationAgency extends UserPO {
     private Long id;
     private Long userId;
     private String bankAccount;

core/src/main/java/com/mooctest/crowd/domain/model/GeneralUser.java

@@ -7,7 +7,7 @@ import lombok.Data;
  * @date 2019/7/6 18:16
  */
 @Data
-public class GeneralUser extends User {
+public class GeneralUser extends UserPO {
     private Long id;
     private Long userId;
 }

core/src/main/java/com/mooctest/crowd/domain/model/RegionalManager.java

@@ -7,7 +7,7 @@ import lombok.Data;
  * @date 2019/7/9 14:16
  */
 @Data
-public class RegionalManager extends User {
+public class RegionalManager extends UserPO {
     private Long id;
     private Long userId;
     private String regional;

core/src/main/java/com/mooctest/crowd/domain/model/User.java → core/src/main/java/com/mooctest/crowd/domain/model/UserPO.java

@@ -12,10 +12,11 @@ import java.sql.Timestamp;
 @Data
 @Table(name = "user")
 @Entity
-public class User {
+public class UserPO {
 
     @Id
-    @GeneratedValue
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "U_ID")
     private Long id;
 
     @Column(name = "U_NAME")
@@ -46,10 +47,10 @@ public class User {
     private String photoUrl;
 
     @Column(name = "U_IS_AVAILABILE")
-    private String isAvailable;
+    private int isAvailable;
 
     @Column(name = "U_IS_DELETED")
-    private String isDeleted;
+    private int isDeleted;
 
     @Column(name = "U_CREATE_TIME")
     private Timestamp createTime;

core/src/main/java/com/mooctest/crowd/domain/repository/AccountUTRepo.java

@@ -2,9 +2,11 @@ package com.mooctest.crowd.domain.repository;
 
 import com.mooctest.crowd.domain.dao.UserDao;
 import com.mooctest.crowd.domain.domainobject.Account;
+import com.mooctest.crowd.domain.domainobject.User;
 import com.mooctest.crowd.domain.exception.AccountNotExistException;
 import com.mooctest.crowd.domain.factory.AccountFactory;
-import com.mooctest.crowd.domain.model.User;
+import com.mooctest.crowd.domain.model.UserPO;
+import com.mooctest.crowd.domain.util.Converter;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -22,20 +24,13 @@ public class AccountUTRepo implements IAccountRepo {
     @Autowired
     private UserDao userDao;
 
-    @Autowired
-    private User user;
-
     @Override
-    public Account getByMobileNum(String mobileNum) throws AccountNotExistException {
+    public User getByMobileNum(String mobileNum) throws AccountNotExistException {
 
-        System.out.println("mobileNum "  + mobileNum);
-        User user = userDao.findByMobile(mobileNum);
-        System.out.println("user "  + user);
-        if (user != null) {
-            Account account = AccountFactory.createAccount();
-            account.setMobileNum(user.getMobile());
-            account.setPassword(user.getPassword());
-            return account;
+        UserPO userPo = userDao.findByMobile(mobileNum);
+        System.out.println("user "  + userPo);
+        if (userPo != null) {
+            return Converter.convert(User.class,userPo);
         }
         throw new AccountNotExistException();
     }
@@ -65,18 +60,19 @@ public class AccountUTRepo implements IAccountRepo {
 
     @Override
     public Account addAccount(Account account){
-        user.setMobile(account.getMobileNum());
-        user.setPassword(account.getPassword());
-        User saveUser = userDao.save(user);
+        UserPO userPo = new UserPO();
+        userPo.setMobile(account.getMobileNum());
+        userPo.setPassword(account.getPassword());
+        UserPO saveUserPO = userDao.save(userPo);
         Account returnAccount = AccountFactory.createAccount();
-        returnAccount.setMobileNum(saveUser.getMobile());
-        returnAccount.setPassword(saveUser.getPassword());
+        returnAccount.setMobileNum(saveUserPO.getMobile());
+        returnAccount.setPassword(saveUserPO.getPassword());
         return returnAccount;
     }
 
     @Override
     public boolean removeAccount(Account account) throws AccountNotExistException {
-        Account byMobileNum = this.getByMobileNum(account.getMobileNum());
+        User byMobileNum = this.getByMobileNum(account.getMobileNum());
         if(byMobileNum != null){
             return true;
         }
@@ -85,11 +81,17 @@ public class AccountUTRepo implements IAccountRepo {
 
     @Override
     public Account updateAccount(Account account) throws AccountNotExistException {
-        Account byMobileNum = this.getByMobileNum(account.getMobileNum());
+        User byMobileNum = this.getByMobileNum(account.getMobileNum());
         if(byMobileNum != null){
-            byMobileNum = account;
-            return byMobileNum;
+//            byMobileNum = account;
+//            return byMobileNum;
+            return null;
         }
         throw new AccountNotExistException();
     }
+
+    public User save(User user) {
+        UserPO userPO = userDao.save(Converter.convert(UserPO.class, user));
+        return Converter.convert(User.class,userPO);
+    }
 }

core/src/main/java/com/mooctest/crowd/domain/repository/IAccountRepo.java

@@ -1,6 +1,7 @@
 package com.mooctest.crowd.domain.repository;
 
 import com.mooctest.crowd.domain.domainobject.Account;
+import com.mooctest.crowd.domain.domainobject.User;
 import com.mooctest.crowd.domain.exception.AccountNotExistException;
 
 import java.util.List;
@@ -11,7 +12,7 @@ import java.util.List;
  */
 public interface IAccountRepo{
 
-    Account getByMobileNum(String mobileNum) throws AccountNotExistException;
+    User getByMobileNum(String mobileNum) throws AccountNotExistException;
 
     Account getByID(Long id) throws AccountNotExistException;
 

core/src/main/java/com/mooctest/crowd/domain/repository/IUserRepo.java

@@ -0,0 +1,27 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.domainobject.User;
+import com.mooctest.crowd.domain.exception.UserNotExistException;
+
+import java.util.List;
+
+/**
+ * @Author: xuexb
+ * @Date: 2019.7.5 14:58
+ */
+public interface IUserRepo {
+
+    User getByMobileNum(String mobileNum) throws UserNotExistException;
+
+    User getByID(Long id) throws UserNotExistException;
+
+    List<User> getByIDList(Long[] ids) throws UserNotExistException;
+
+    User addUser(User user) throws UserNotExistException;
+
+    boolean removeUser(User user) throws UserNotExistException;
+
+    User updateUser(User user) throws UserNotExistException;
+
+    User save(User user);
+}

core/src/main/java/com/mooctest/crowd/domain/repository/UserRepo.java

@@ -0,0 +1,91 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.dao.UserDao;
+import com.mooctest.crowd.domain.domainobject.User;
+import com.mooctest.crowd.domain.exception.UserNotExistException;
+import com.mooctest.crowd.domain.factory.UserFactory;
+import com.mooctest.crowd.domain.model.UserPO;
+import com.mooctest.crowd.domain.util.Converter;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @Author: xuexb
+ * @Date: 2019.7.5 14:28
+ */
+
+@Component
+public class UserRepo implements IUserRepo {
+
+    @Autowired
+    private UserDao userDao;
+
+    @Override
+    public User getByMobileNum(String mobileNum) throws UserNotExistException {
+
+        UserPO userPo = userDao.findByMobile(mobileNum);
+        System.out.println("user "  + userPo);
+        if (userPo != null) {
+            return Converter.convert(User.class,userPo);
+        }
+        throw new UserNotExistException();
+    }
+
+    @Override
+    public User getByID(Long id) throws UserNotExistException {
+        if (id.equals(123L)) {
+            User user = new User();
+            user.setId(id);
+            user.setMobile("EXIST_ACCOUNT");
+            user.setPassword("PASSWORD");
+            return user;
+        }
+        throw new UserNotExistException();
+    }
+
+    @Override
+    public List<User> getByIDList(Long[] ids) throws UserNotExistException {
+
+        List<User> userList = new ArrayList<User>();
+        for (Long id: ids) {
+            User user = getByID(id);
+            userList.add(user);
+        }
+        return userList;
+    }
+
+    @Override
+    public User addUser(User user){
+        UserPO userPo = new UserPO();
+        userPo.setMobile(user.getMobile());
+        userPo.setPassword(user.getPassword());
+        UserPO saveUserPO = userDao.save(userPo);
+        User returnUser = UserFactory.createUser();
+        returnUser.setMobile(saveUserPO.getMobile());
+        returnUser.setPassword(saveUserPO.getPassword());
+        return returnUser;
+    }
+
+    @Override
+    public boolean removeUser(User user) throws UserNotExistException {
+        User byMobileNum = this.getByMobileNum(user.getMobile());
+        if(byMobileNum != null){
+            return true;
+        }
+        throw new UserNotExistException();
+    }
+
+    @Override
+    public User updateUser(User user) throws UserNotExistException {
+        UserPO saveResultUser = userDao.save(Converter.convert(UserPO.class, user));
+        return Converter.convert(User.class,saveResultUser);
+    }
+
+    public User save(User user) {
+        UserPO userPO = userDao.save(Converter.convert(UserPO.class, user));
+        return Converter.convert(User.class,userPO);
+    }
+}

core/src/main/java/com/mooctest/crowd/domain/util/Converter.java

@@ -0,0 +1,82 @@
+package com.mooctest.crowd.domain.util;
+
+import com.google.common.collect.Maps;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springframework.cglib.beans.BeanCopier;
+
+import java.util.Map;
+
+public class Converter {
+
+    private static Map<CopierIdentity, BeanCopier> copierCache = Maps.newConcurrentMap();
+    private static PrimitiveConverter primitiveConverter = new PrimitiveConverter();
+
+    public static <T> T copy(T target, Object source) {
+        BeanCopier copier = getCopier(source.getClass(), target.getClass());
+        copier.copy(source, target, primitiveConverter);
+        return target;
+    }
+
+    public static <T> T convert(Class<T> targetClass, Object source) {
+        try {
+            T target = targetClass.newInstance();
+            BeanCopier copier = getCopier(source.getClass(), targetClass);
+            copier.copy(source, target, primitiveConverter);
+            return target;
+        } catch (InstantiationException | IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static BeanCopier getCopier(Class<?> source, Class<?> target) {
+        CopierIdentity identity = new CopierIdentity(source, target);
+        BeanCopier copier;
+        if (copierCache.containsKey(identity)) {
+            copier = copierCache.get(identity);
+        } else {
+            copier = BeanCopier.create(source, target, true);
+            copierCache.putIfAbsent(identity, copier);
+        }
+        return copier;
+    }
+
+    public static class PrimitiveConverter implements org.springframework.cglib.core.Converter {
+        @Override
+        @SuppressWarnings("unchecked")
+        public Object convert(Object value, Class target, Object context) {
+            if (value == null) return null;
+            if (target.equals(String.class)
+                    && !String.class.isAssignableFrom(value.getClass()))
+                return value.toString();
+            if (Number.class.isAssignableFrom(value.getClass())) {
+                Number num = (Number) value;
+                if (target.equals(int.class) || target.equals(Integer.class))
+                    return num.intValue();
+                else if (target.equals(long.class) || target.equals(Long.class))
+                    return num.longValue();
+                else if (target.equals(short.class) || target.equals(Short.class))
+                    return num.shortValue();
+                else if (target.equals(float.class) || target.equals(Float.class))
+                    return num.floatValue();
+                else if (target.equals(double.class) || target.equals(Double.class))
+                    return num.doubleValue();
+                else if (target.equals(byte.class) || target.equals(Byte.class))
+                    return num.byteValue();
+            } else if (target.isAssignableFrom(value.getClass()))
+                return value;
+            return null;
+        }
+    }
+
+    @AllArgsConstructor
+    @Data
+    @EqualsAndHashCode
+    private static class CopierIdentity {
+        private Class<?> source;
+        private Class<?> target;
+    }
+
+}
+

core/src/main/java/com/mooctest/crowd/domain/util/EncryptionUtil.java

@@ -0,0 +1,212 @@
+package com.mooctest.crowd.domain.util;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import sun.misc.BASE64Decoder;
+import sun.misc.BASE64Encoder;
+
+import javax.crypto.Cipher;
+import javax.crypto.SecretKey;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.spec.DESKeySpec;
+import java.io.IOException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+
+public class EncryptionUtil {
+
+    private static final Logger LOG = LoggerFactory.getLogger(EncryptionUtil.class);
+
+    // 定义 加密算法,可用 DES,DESede,Blowfish
+    private static String Algorithm = "DES";
+    private static String defaultKey = "witest.net";
+
+
+    public static String encryptMD5Hex(String str) {
+        String value = null;
+        // 用来将字节转换成 16 进制表示的字符
+        char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+
+        try {
+            MessageDigest md5 = MessageDigest.getInstance("MD5");
+            md5.update(str.getBytes());
+
+            // MD5 的计算结果是一个 128 位的长整数，用字节表示就是 16 个字节
+            byte temp[] = md5.digest();
+            // 每个字节用 16 进制表示的话，使用两个字符
+            char hex[] = new char[16 * 2];
+
+            // 表示转换结果中对应的字符位置
+            int k = 0;
+            // 从第一个字节开始，对 MD5 的每一个字节转换成 16 进制字符的转换
+            for (int i = 0; i < 16; i++) {
+                byte b = temp[i];
+                // 取字节中高 4 位的数字转换, >>> 为逻辑右移，将符号位一起右移
+                hex[k++] = hexDigits[b >>> 4 & 0xf];
+                // 取字节中低 4 位的数字转换
+                hex[k++] = hexDigits[b & 0xf];
+            }
+
+            // 转换后的结果转换为字符串
+            value = new String(hex);
+
+        } catch (Exception e) {
+            value = "";
+            LOG.error("", e);
+        }
+        return value;
+    }
+
+    public static String encryptMD5(String str) {
+        String s = str;
+        if (s == null) {
+            return "";
+        } else {
+            String value = null;
+            MessageDigest md5 = null;
+            try {
+                md5 = MessageDigest.getInstance("MD5");
+            } catch (NoSuchAlgorithmException ex) {
+                LOG.error("", ex);
+            }
+            sun.misc.BASE64Encoder baseEncoder = new sun.misc.BASE64Encoder();
+            try {
+                value = baseEncoder.encode(md5.digest(s.getBytes("utf-8")));
+            } catch (Exception ex) {
+            }
+            return value;
+        }
+    }
+
+    public static String transferMD5ToMD5Hex(String str) {
+
+        String value = null;
+        // 用来将字节转换成 16 进制表示的字符
+        char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+        BASE64Decoder base64Decoder = new BASE64Decoder();
+        try {
+            byte[] temp = base64Decoder.decodeBuffer(str);
+            // 每个字节用 16 进制表示的话，使用两个字符
+            char hex[] = new char[16 * 2];
+
+            // 表示转换结果中对应的字符位置
+            int k = 0;
+            // 从第一个字节开始，对 MD5 的每一个字节转换成 16 进制字符的转换
+            for (int i = 0; i < 16; i++) {
+                byte b = temp[i];
+                // 取字节中高 4 位的数字转换, >>> 为逻辑右移，将符号位一起右移
+                hex[k++] = hexDigits[b >>> 4 & 0xf];
+                // 取字节中低 4 位的数字转换
+                hex[k++] = hexDigits[b & 0xf];
+            }
+
+            // 转换后的结果转换为字符串
+            value = new String(hex);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return value;
+
+    }
+
+    public static String encryptDES(String content) throws Exception {
+        return encryptDES(content, defaultKey);
+    }
+
+    public static String decryptDES(String content) throws Exception {
+        return decryptDES(content, defaultKey);
+    }
+
+
+    /**
+     * Description 根据键值进行加密
+     *
+     * @param data
+     * @param key  加密键byte数组
+     * @return
+     * @throws Exception
+     */
+    public static String encryptDES(String data, String key) throws Exception {
+        byte[] bt = encryptDES(data.getBytes(), key.getBytes());
+        String strs = new BASE64Encoder().encode(bt);
+        return strs;
+    }
+
+    /**
+     * Description 根据键值进行解密
+     *
+     * @param data
+     * @param key  加密键byte数组
+     * @return
+     * @throws IOException
+     * @throws Exception
+     */
+    public static String decryptDES(String data, String key) throws IOException,
+            Exception {
+        if (data == null)
+            return null;
+        BASE64Decoder decoder = new BASE64Decoder();
+        byte[] buf = decoder.decodeBuffer(data);
+        byte[] bt = decryptDES(buf, key.getBytes());
+        return new String(bt);
+    }
+
+    /**
+     * Description 根据键值进行加密
+     *
+     * @param data
+     * @param key  加密键byte数组
+     * @return
+     * @throws Exception
+     */
+    private static byte[] encryptDES(byte[] data, byte[] key) throws Exception {
+        // 生成一个可信任的随机数源
+        SecureRandom sr = new SecureRandom();
+
+        // 从原始密钥数据创建DESKeySpec对象
+        DESKeySpec dks = new DESKeySpec(key);
+
+        // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
+        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(Algorithm);
+        SecretKey securekey = keyFactory.generateSecret(dks);
+
+        // Cipher对象实际完成加密操作
+        Cipher cipher = Cipher.getInstance(Algorithm);
+
+        // 用密钥初始化Cipher对象
+        cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);
+
+        return cipher.doFinal(data);
+    }
+
+
+    /**
+     * Description 根据键值进行解密
+     *
+     * @param data
+     * @param key  加密键byte数组
+     * @return
+     * @throws Exception
+     */
+    private static byte[] decryptDES(byte[] data, byte[] key) throws Exception {
+        // 生成一个可信任的随机数源
+        SecureRandom sr = new SecureRandom();
+
+        // 从原始密钥数据创建DESKeySpec对象
+        DESKeySpec dks = new DESKeySpec(key);
+
+        // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
+        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(Algorithm);
+        SecretKey securekey = keyFactory.generateSecret(dks);
+
+        // Cipher对象实际完成解密操作
+        Cipher cipher = Cipher.getInstance(Algorithm);
+
+        // 用密钥初始化Cipher对象
+        cipher.init(Cipher.DECRYPT_MODE, securekey, sr);
+
+        return cipher.doFinal(data);
+    }
+
+}

core/src/test/java/com/mooctest/crowd/domain/domainobject/UserTest.java

@@ -0,0 +1,239 @@
+package com.mooctest.crowd.domain.domainobject;
+
+import com.mooctest.crowd.domain.command.LoginCommand;
+import com.mooctest.crowd.domain.exception.PasswordErrorException;
+import com.mooctest.crowd.domain.exception.UserNotExistException;
+import com.mooctest.crowd.domain.repository.UserRepo;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class UserTest {
+    @InjectMocks
+    private User user = new User();
+
+    @Mock
+    private UserRepo userRepo;
+
+    private LoginCommand loginCommand = new LoginCommand();
+
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+
+    @Before
+    public void setUp(){
+        MockitoAnnotations.initMocks(this);
+
+        loginCommand.setMobileNum("13657094936");
+        loginCommand.setPassword("123456");
+
+        user.setMobile("13657094936");
+        user.setPassword("4QrcOUm6Wau+VuBX8g+IPg==");
+
+    }
+
+    @Test
+    public void should_return_true_when_login_success() throws PasswordErrorException, UserNotExistException {
+        // arrange
+        when(userRepo.getByMobileNum("13657094936")).thenReturn(user);
+        // action
+        boolean success = user.login(loginCommand.getMobileNum(),loginCommand.getPassword());
+        // assert
+        assertTrue(success);
+    }
+
+    @Test(expected = UserNotExistException.class)
+    public void should_throw_when_user_not_exist() throws UserNotExistException, PasswordErrorException {
+        // arrange
+        loginCommand.setMobileNum("NOT_EXIST");
+        when(userRepo.getByMobileNum("NOT_EXIST")).thenReturn(null);
+        user.login(loginCommand.getMobileNum(),loginCommand.getPassword());
+    }
+
+//
+//    @Test(expected = PasswordErrorException.class)
+//    public void should_throw_exception_when_password_error() throws PasswordErrorException, AccountNotExistException {
+//        // arrange
+//        LoginCommand loginCommand = new LoginCommand();
+//        loginCommand.setMobileNum("EXIST_ACCOUNT");
+//        loginCommand.setPassword("ERROR_PASSWORD");
+//        IAccountRepo IAccountRepo = new AccountUTRepo();
+//        Account account = IAccountRepo.getByMobileNum(loginCommand.getMobileNum());
+//        // assert
+//        account.login(loginCommand);
+//    }
+//
+//    @Test
+//    public void should_update_password_when_modify_password() throws AccountNotExistException, PasswordErrorException {
+//        // arrange
+//        ModifyPasswordCommand modifyPasswordCommand = new ModifyPasswordCommand();
+//        modifyPasswordCommand.setMobileNum("EXIST_ACCOUNT");
+//        modifyPasswordCommand.setOldPassword("PASSWORD");
+//        modifyPasswordCommand.setNewPassword("654321");
+//
+//        Account account = accountUTRepo.getByMobileNum(modifyPasswordCommand.getMobileNum());
+//        // action
+//        boolean result = account.modifyPassword(modifyPasswordCommand);
+//        // assert
+//        assertTrue(result);
+//    }
+//
+//    @Test
+//    public void should_return_permissions_when_account_login_success() throws AccountNotExistException {
+//        // arrange
+//        Account account = this.getSuccessAccount();
+//        // action
+//        List<Permission> permissions = account.distributePermission();
+//        // assert
+//        assertEquals(permissions.get(0).getId(), new Long(1));
+//    }
+//
+//    @Test
+//    public void should_return_roles_when_account_login_success() throws AccountNotExistException {
+//        // arrange
+//        Account account = this.getSuccessAccount();
+//        // action
+//        List<Role> roles = account.distributeRole();
+//        // assert
+//        assertEquals(roles.get(0).getId(), new Long(1));
+//    }
+//
+//    @Test
+//    public void should_return_account_when_view_by_account_id() throws AccountNotExistException {
+//        // arrange
+//        AccountCommand accountCommand = new AccountCommand();
+//        accountCommand.setId(123L);
+//
+//        // action
+//        Account accountUTRepoByID = accountUTRepo.getByID(accountCommand.getId());
+//        // assert
+//        assertEquals(accountUTRepoByID.getId(), accountCommand.getId());
+//    }
+//
+//    @Test(expected = AccountNotExistException.class)
+//    public void should_throw_when_view_account_not_exist_by_account_id() throws AccountNotExistException {
+//        // arrange
+//        AccountCommand accountCommand = new AccountCommand();
+//        accountCommand.setId(111L);
+//        // action
+//        accountUTRepo.getByID(accountCommand.getId());
+//    }
+//
+//    @Test
+//    public void should_return_account_list_when_view_by_account_ids() throws AccountNotExistException {
+//        // arrange
+//        Long[] ids = {123L};
+//        // action
+//        List<Account> accountList = accountUTRepo.getByIDList(ids);
+//        // assert
+//        assertEquals(accountList.get(0).getId(), ids[0]);
+//    }
+//
+//    @Test(expected = AccountNotExistException.class)
+//    public void should_throw_when_view_not_exist_account_by_account_ids() throws AccountNotExistException {
+//        // arrange
+//        Long[] ids = {123L,111L};
+//
+//        // action
+//        accountUTRepo.getByIDList(ids);
+//    }
+//
+//    @Test
+//    public void should_return_false_when_add_exist_account(){
+//        // arrange
+//        Account account = this.createCorrectAccount();
+//        // action
+//        Account resultAccount = accountUTRepo.addAccount(account);
+//        // assert
+//        assertEquals(resultAccount.getMobileNum(),account.getMobileNum());
+//    }
+//
+//    //    @Test(expected = AccountNotExistException.class)
+////    public void should_throw_when_add_account_success() throws AccountNotExistException {
+////        // arrange
+////        Account account = this.createDiscorrectAccount();
+////        // action
+////        accountUTRepo.addAccount(account);
+////    }
+//    @Test
+//    public void should_return_true_when_remove_account_success() throws AccountNotExistException {
+//        // arrange
+//        Account account = this.createCorrectAccount();
+//        // action
+//        boolean result = accountUTRepo.removeAccount(account);
+//        // assert
+//        assertTrue(result);
+//    }
+//
+//    @Test(expected = AccountNotExistException.class)
+//    public void should_throw_when_remove_not_exist_account() throws AccountNotExistException {
+//        // arrange
+//        Account account = this.createDiscorrectAccount();
+//        // action
+//        accountUTRepo.removeAccount(account);
+//    }
+//
+//    @Test
+//    public void should_return_true_when_update_account_success() throws AccountNotExistException {
+//        // arrange
+//        Account account = this.createCorrectAccount();
+//        account.setPassword("UPDATE_PASSWORD");
+//        // action
+//        Account updateAccount = accountUTRepo.updateAccount(account);
+//        // assert
+//        assertEquals(updateAccount.getPassword(),account.getPassword());
+//    }
+//
+//    @Test(expected = AccountNotExistException.class)
+//    public void should_throw_when_update_not_exist_account() throws AccountNotExistException {
+//        // arrange
+//        Account account = this.createDiscorrectAccount();
+//        // action
+//        accountUTRepo.updateAccount(account);
+//    }
+//
+//    private LoginCommand getSuccessLoginCommand() {
+//        LoginCommand loginCommand = new LoginCommand();
+//        loginCommand.setMobileNum("EXIST_ACCOUNT");
+//        loginCommand.setPassword("PASSWORD");
+//        loginCommand.setCheckCode("123456");
+//        return loginCommand;
+//    }
+//
+//    private Account getSuccessAccount() throws AccountNotExistException {
+//        LoginCommand loginCommand = getSuccessLoginCommand();
+//        IAccountRepo IAccountRepo = new AccountUTRepo();
+//        return IAccountRepo.getByMobileNum(loginCommand.getMobileNum());
+//    }
+//
+//    private Account createCorrectAccount(){
+//        AccountCommand accountCommand = new AccountCommand();
+//        accountCommand.setMobileNum("EXIST_ACCOUNT");
+//        accountCommand.setPassword("PASSWORD");
+//        Account account = new Account();
+//        account.setMobileNum(accountCommand.getMobileNum());
+//        account.setPassword(accountCommand.getPassword());
+//        return account;
+//    }
+//
+//    private Account createDiscorrectAccount(){
+//        AccountCommand accountCommand = new AccountCommand();
+//        accountCommand.setMobileNum("NOT_EXIST_ACCOUNT");
+//        accountCommand.setPassword("PASSWORD");
+//        Account account = new Account();
+//        account.setMobileNum(accountCommand.getMobileNum());
+//        account.setPassword(accountCommand.getPassword());
+//        return account;
+//    }
+
+}

core/src/test/java/com/mooctest/crowd/domain/domainservice/RegisterDServiceTest.java

@@ -1,32 +1,38 @@
 package com.mooctest.crowd.domain.domainservice;
 
 import com.mooctest.crowd.domain.command.RegisterCommand;
-import com.mooctest.crowd.domain.domainobject.Account;
+import com.mooctest.crowd.domain.domainobject.User;
 import com.mooctest.crowd.domain.exception.AccountNotExistException;
 import com.mooctest.crowd.domain.exception.HttpBadRequestException;
-import com.mooctest.crowd.domain.repository.AccountUTRepo;
+import com.mooctest.crowd.domain.exception.UserNotExistException;
+import com.mooctest.crowd.domain.repository.UserRepo;
 import org.junit.Before;
 import org.junit.Rule;
+import org.junit.Test;
 import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import org.mockito.runners.MockitoJUnitRunner;
 
-import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.when;
 
 /**
  * @Author: xuexb
  * @Date: 2019.7.5 14:09
  */
+@RunWith(MockitoJUnitRunner.class)
 public class RegisterDServiceTest {
     @InjectMocks
     private RegisterDService registerDService = new RegisterDService();
 
     @Mock
-    private AccountUTRepo accountUTRepo;
+    private UserRepo userRepo;
 
-    private Account account = new Account();
+    private User user =  new User();
 
     private RegisterCommand registerCommand = new RegisterCommand();
 
@@ -34,36 +40,82 @@ public class RegisterDServiceTest {
     public ExpectedException thrown = ExpectedException.none();
 
     @Before
-    public void setUp() throws AccountNotExistException {
+    public void setUp(){
         MockitoAnnotations.initMocks(this);
 
         registerCommand.setMobileNum("13657094936");
-        registerCommand.setCheckCode("XXXX");
-        registerCommand.setPassword("12341324");
+        registerCommand.setPassword("123456");
 
-        account.setMobileNum("18652040322");
-        account.setPassword("12341324");
+        user.setMobile("13657094936");
+        user.setPassword("123456");
 
     }
 
 
-    @org.junit.Test
-    public void should_register_success_when_user_register_by_mobile_num() throws AccountNotExistException {
+    @Test
+    public void should_register_success_when_user_register_by_mobile_num() throws AccountNotExistException, UserNotExistException {
 
         // action
-        when(accountUTRepo.getByMobileNum("13657094936")).thenReturn(null);
-        Account newAccount = registerDService.register(registerCommand.getMobileNum(),registerCommand.getPassword());
+        when(userRepo.getByMobileNum("13657094936")).thenReturn(null);
+        when(userRepo.save(any(User.class))).thenReturn(user);
+        User registerUser = registerDService.register(registerCommand.getMobileNum(), registerCommand.getPassword());
 
         // assert
-        assertNull(newAccount);
+        assertNotNull(registerUser);
 
     }
-    @org.junit.Test
-    public void should_thow_exception_when_mobile_num_exist() throws AccountNotExistException {
+    @Test
+    public void should_thow_exception_when_mobile_num_exist() throws AccountNotExistException, UserNotExistException {
 
-        when(accountUTRepo.getByMobileNum("18652040322")).thenReturn(account);
+        when(userRepo.getByMobileNum("18652040322")).thenReturn(user);
         thrown.expect(HttpBadRequestException.class);
         registerCommand.setMobileNum("18652040322");
         registerDService.register(registerCommand.getMobileNum(),registerCommand.getPassword());
     }
+//    @InjectMocks
+//    private RegisterDService registerDService = new RegisterDService();
+//
+//    @Mock
+//    private UserRepo userRepo;
+//
+//    private User user =  new User();
+//
+//    private RegisterCommand registerCommand = new RegisterCommand();
+//
+//    @Rule
+//    public ExpectedException thrown = ExpectedException.none();
+//
+//    @Before
+//    public void setUp(){
+//        MockitoAnnotations.initMocks(this);
+//
+//        registerCommand.setMobileNum("13657094936");
+//        registerCommand.setPassword("123456");
+//
+//        user.setMobile("13657094936");
+//        user.setPassword("123456");
+//
+//    }
+//
+//
+//    @Test
+//    public void should_register_success_when_user_register_by_mobile_num() throws AccountNotExistException, UserNotExistException {
+//
+//        // action
+//        when(userRepo.getByMobileNum("13657094936")).thenReturn(null);
+//        when(userRepo.save(any(User.class))).thenReturn(user);
+//        User registerUser = registerDService.register(registerCommand.getMobileNum(), registerCommand.getPassword());
+//
+//        // assert
+//        assertNotNull(registerUser);
+//
+//    }
+//    @Test
+//    public void should_thow_exception_when_mobile_num_exist() throws AccountNotExistException, UserNotExistException {
+//
+//        when(userRepo.getByMobileNum("18652040322")).thenReturn(user);
+//        thrown.expect(HttpBadRequestException.class);
+//        registerCommand.setMobileNum("18652040322");
+//        registerDService.register(registerCommand.getMobileNum(),registerCommand.getPassword());
+//    }
 }

core/src/test/java/com/mooctest/crowd/domain/repository/AccountUTRepoTest.java

@@ -0,0 +1,74 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.dao.UserDao;
+import com.mooctest.crowd.domain.domainobject.User;
+import com.mooctest.crowd.domain.exception.AccountNotExistException;
+import com.mooctest.crowd.domain.model.UserPO;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class AccountUTRepoTest {
+
+    @InjectMocks
+    private AccountUTRepo accountUTRepo = new AccountUTRepo();
+
+    @Mock
+    private UserDao userDao;
+
+    private UserPO userPO =  new UserPO();
+
+    private User user =  new User();
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+
+        user.setMobile("13657094936");
+        user.setPassword("123456");
+
+        userPO.setMobile("13657094936");
+        userPO.setPassword("123456");
+    }
+
+    @Test
+    public void show_return_user_when_getbymobilenum_mobile_num_exist() throws AccountNotExistException {
+
+        when(userDao.findByMobile("13657094936")).thenReturn(userPO);
+        User user = accountUTRepo.getByMobileNum("13657094936");
+//        assertEquals(user.getPassword(), EncryptionUtil.encryptMD5(userPO.getPassword()));
+        assertEquals(user.getPassword(), "123456");
+    }
+
+    @Test
+    public void getByID() {
+    }
+
+    @Test
+    public void getByIDList() {
+    }
+
+    @Test
+    public void addAccount() {
+    }
+
+    @Test
+    public void removeAccount() {
+    }
+
+    @Test
+    public void updateAccount() {
+    }
+
+    @Test
+    public void save() {
+    }
+}

core/src/test/java/com/mooctest/crowd/domain/repository/UserRepoTest.java

@@ -0,0 +1,38 @@
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.dao.UserDao;
+import com.mooctest.crowd.domain.domainobject.User;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.runners.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class UserRepoTest {
+    @InjectMocks
+    private UserRepo userRepo = new UserRepo();
+
+    @Mock
+    private UserDao userDao;
+
+    private User user =  new User();
+
+    @Before
+    public void before() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void test_getByMobileNum() {
+    }
+
+    @Test
+    public void test_save() {
+        user.setMobile("12345678911");
+        user.setPassword("123456");
+        userRepo.save(user);
+    }
+}

site/src/main/java/com/mooctest/crowd/site/controller/CommonController.java

@@ -1 +1 @@
-package com.mooctest.crowd.site.controller;


import com.mooctest.crowd.site.constants.ResponseConstant;
import com.mooctest.crowd.site.data.ResponseMessage;
import com.mooctest.crowd.site.data.dto.IndexDTO;
import com.mooctest.crowd.site.service.CommonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author: xuexb
 * @Date: 2019.7.22 16:51
 */
@RestController
public class CommonController {

    @Autowired
    private CommonService commonService;

    @RequestMapping(value = "/index", method = RequestMethod.GET)
    public ResponseMessage<IndexDTO> index(){
        return new ResponseMessage<>(ResponseConstant.OK,
                ResponseConstant.REQUEST_SUCCESS,
                commonService.getIndexInfo());
    }
}
+package com.mooctest.crowd.site.controller;


import com.mooctest.crowd.site.constants.ResponseConstant;
import com.mooctest.crowd.site.data.ResponseMessage;
import com.mooctest.crowd.site.data.dto.IndexDTO;
import com.mooctest.crowd.site.service.CommonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author: xuexb
 * @Date: 2019.7.22 16:51
 */
@RestController
public class CommonController {

    @Autowired
    private CommonService commonService;

    @RequestMapping(value = "/index", method = RequestMethod.GET)
    public ResponseMessage<IndexDTO> index(){
        return new ResponseMessage<>(ResponseConstant.OK,
                ResponseConstant.REQUEST_SUCCESS,
                commonService.getIndexInfo());
    }

    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public String hello() {
//        RegisterDService registerDService = new RegisterDService();
//        try {
//            User register = registerDService.register("13657094936", "123456");
//            System.out.println("sdfdsf");
//        } catch (UserNotExistException e) {
//            System.out.println("exist");
//            e.printStackTrace();
//        }
        return "Hello, Spring Boot!";
    }
}

site/src/main/java/com/mooctest/crowd/site/mediator/impl/WebMediatorImpl.java

@@ -1,15 +1,12 @@
 package com.mooctest.crowd.site.mediator.impl;
 
-import com.mooctest.crowd.site.data.dto.*;
-import com.mooctest.crowd.site.command.*;
-import com.mooctest.crowd.site.data.vo.*;
-import com.mooctest.crowd.domain.domainobject.Account;
 import com.mooctest.crowd.domain.exception.AccountNotExistException;
 import com.mooctest.crowd.domain.exception.BadRequestException;
 import com.mooctest.crowd.domain.exception.PasswordErrorException;
-import com.mooctest.crowd.site.mediator.Mediator;
-import com.mooctest.crowd.domain.domainservice.RegisterDService;
 import com.mooctest.crowd.domain.repository.AccountUTRepo;
+import com.mooctest.crowd.site.command.*;
+import com.mooctest.crowd.site.data.dto.*;
+import com.mooctest.crowd.site.mediator.Mediator;
 import org.springframework.stereotype.Component;
 
 /**
@@ -23,19 +20,21 @@ public class WebMediatorImpl implements Mediator {
 
     @Override
     public UserDTO loginByMobileAndPwd(LoginCommand cmd) throws PasswordErrorException, AccountNotExistException, BadRequestException {
-        Account account = accountUTRepo.getByMobileNum(cmd.getMobileNum());
-        if (account.login(cmd.getMobileNum(),cmd.getPassword())) {
-            UserVO userVO = new UserVO(account);
-            return new UserDTO(userVO);
-        }else
-            throw new BadRequestException("登录失败");
+//        User byMobileNum = accountUTRepo.getByMobileNum(cmd.getMobileNum());
+//        if (account.login(cmd.getMobileNum(),cmd.getPassword())) {
+//            UserVO userVO = new UserVO(account);
+//            return new UserDTO(userVO);
+//        }else
+//            throw new BadRequestException("登录失败");
+        return null;
     }
 
     @Override
     public UserDTO register(RegisterCommand registerCommand) throws AccountNotExistException {
-        Account account = new RegisterDService().register(registerCommand.getMobileNum(), registerCommand.getPassword());
-        UserVO userVO = new UserVO(account);
-        return new UserDTO(userVO);
+//        Account account = new RegisterDService().register(registerCommand.getMobileNum(), registerCommand.getPassword());
+//        UserVO userVO = new UserVO(account);
+//        return new UserDTO(userVO);
+        return null;
     }
 
     @Override