从SSM到SpringBoot

SSM,即Spring、SpringMVC、MyBatis。

Spring框架具有IOC/DI、AOP特性。

IOC(Inversion Of Control)与DI(Dependency Injection)指同一个特性。
Spring支持使用BeanFactory来获取Bean形式的对象,例如将Mapper层类的实例注入到Service层类的实例中,再将Service层类的实例注入到Controller层类的实例中。

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountMapper accountMapper;

    @Override
    public int deleteByPrimaryKey(Long id) {
        return accountMapper.deleteByPrimaryKey(id);
    }

    @Override
    public int insert(Account record) {

        return accountMapper.insert(record);
    }

    @Override
    public int insertSelective(Account record) {
        return 0;
    }

    @Override
    public Account selectByPrimaryKey(Long id) {

        return accountMapper.selectByPrimaryKey(id);
    }

    @Override
    public Account login(String accountName, String accountPwd) {

        return accountMapper.login(accountName,accountPwd);
    }

    @Override
    public List<Account> queryAll() {
        return accountMapper.queryAll();
    }

    @Override
    public int updateByPrimaryKeySelective(Account record) {
        return 0;
    }

    @Override
    public int updateByPrimaryKey(Account record) {

        return accountMapper.updateByPrimaryKey(record);
    }
}

@RestController
@RequestMapping("account")
public class AccountController {
    @Autowired
    private AccountService accountService;

    @GetMapping(value = "loginDo")
    @ResponseBody
    public Result login(String accountName, String accountPwd, HttpSession session){

        Account account = accountService.login(accountName, accountPwd);
        if(account!=null){
            session.setAttribute("account",account);
            return Result.ok();
        }else {
            return Result.error("用户名或密码错误");
        }


    }

    @GetMapping(value = "queryAll")
    @ResponseBody
    public Result queryAll(){

        List<Account> list = accountService.queryAll();
        return Result.ok().data("list",list);
    }

    @GetMapping(value = "queryById")
    @ResponseBody
    public Result queryById(Long id){
        Account account = accountService.selectByPrimaryKey(id);
        return Result.ok().data("account",account);

    }

    @PostMapping(value = "/addDo")
    @ResponseBody
    public Object add(Account account){

        int result = accountService.insert(account);
        HashMap<String, Integer> map = new HashMap<>();
        map.put("code",result>0 ? 200 : 500);
        return map;
    }

    @GetMapping(value = "delete")
    @ResponseBody
    public Object delete(Long id){

        int result = accountService.deleteByPrimaryKey(id);
        HashMap<String, Integer> map = new HashMap<>();
        map.put("code",result>0 ? 200 : 500);
        return map;
    }

    @PostMapping(value = "update")
    @ResponseBody
    public void update(Account account){

        int result = accountService.updateByPrimaryKey(account);
        HashMap<String, Integer> map = new HashMap<>();
        map.put("code",result>0 ? 200 : 500);
    }

}

IOC/DI使得项目代码的可维护性、可扩展性得以增强。

AOP，即Aspect Oriented Programming,Spring支持将项目中诸多类都要完成的类似功能提取出来编写为切面类,将需要功能的类与切面类的通知(功能)配合使用即可。
例如：

@Aspect  // 表明是一个切面类
@Component
public class LogAspect {
    Logger log = Logger.getLogger(LogAspect.class);

    //进入方法时间戳
    private Long startTime;
    //方法结束时间戳(计时)
    private Long endTime;
    /**
     * 定义切入点表达式
     * 访问修饰符 返回值 包名.包名.包名...类名.方法名(参数列表)
     * 权限修饰符可以使用默认 第一个*表示返回值类型  ..表示当前包以及其子包下 第二个*表示任意方法 (..)表示任意参数列表
     */
    private final String POINTCUT = "execution(* com.woniuxy.ssm.service.*.*(..))";

    public LogAspect() {
    }

    //前置通知，方法之前执行
    @Before(POINTCUT)
    public void doBefore(JoinPoint joinPoint) {
        startTime = System.currentTimeMillis();
        log.info("请求开始时间：" + LocalDateTime.now());
        log.info("请求参数 : " + Arrays.toString(joinPoint.getArgs()));
    }

    //后置通知
    @After(POINTCUT)
    public void doAfter(JoinPoint joinPoint) {
        log.info("Logger-->后置通知，方法名：" + joinPoint.getSignature().getName() + "，方法执行完毕");
    }

    //返回通知 正常结束时进入此方法
    @AfterReturning(returning = "ret", pointcut = POINTCUT)
    public void doAfterReturning(Object ret) {
        endTime = System.currentTimeMillis();
        log.info("请求结束时间 : " + LocalDateTime.now());
        log.info("请求耗时 : " + (endTime - startTime));
        // 处理完请求，返回内容
        log.info("请求返回 : " + ret);
    }

    //异常通知： 1. 在目标方法非正常结束，发生异常或者抛出异常时执行
    @AfterThrowing(pointcut = POINTCUT, throwing = "throwable")
    public void doAfterThrowing(Throwable throwable) {
        // 保存异常日志记录
        log.error("发生异常时间 : " + LocalDateTime.now());
        log.error("抛出异常 : " + throwable.getMessage());
    }

    //环绕通知,必须有返回值，否则程序无法继续往下执行，返回空指针异常
    @Around(value = POINTCUT)
    public Object doAround(ProceedingJoinPoint jp) throws Throwable {
        log.info("权限管理");
        //执行目标方法proceed
        Object proceed = jp.proceed();
        log.info("日志记录");
        return proceed;
    }
}

AOP使得代理变得更加简洁、容易。

SpringMVC是Spring框架的一部分，用于简化Controller层中对于接收到的数据的预处理(切分、类型转换、封装为对象)，使得Controller层的代码更加精简。

Controller层的一个方法示例:

@Autowired
private UserService userService;
@RequestMapping("/login")
//参数的名称应该和客户端请求参数的名称保持一致
//使用ServletAPI相关的方式：给方法加对应类型的参数
public String login(String telephone, String password, HttpSession session){

    User user = userService.getUserByNameAndPwd(telephone,password);
    if(user!=null){
        session.setAttribute("login_user",user);//用session来传值
         return "redirect:main";
        }else {
            return "redirect:login";
        }
}

MyBatis是一款作用于持久层的框架,MyBatis支持自动生成entity层实体类和mapper层的接口、xml、实现类，也支持自定义SQL。MyBatis大大的减少了entity层、mapper层的代码,帮助开发者将更多精力用于service层、controller层。

在组合使用SSM来构建项目时,需要导入很多的依赖并进行相关的配置,如果稍有不慎少导入一个依赖或配置文件中少了某一项，会影响应用的正常运行。
SpringBoot可以简化很多依赖的导入工作(将众多依赖项包装为一个starter，只需导入starter即可)、相关的配置工作(自动执行对应的配置，无需手动配置)，使得项目的构建变得更快,开发者可以将更多精力用于构建service层、controller层。

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.7</version>
        </dependency>
        <!-- thymeleaf依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
    </dependencies>