关于spring:从SSM到SpringBoot

1. SSM

SSM,即Spring、SpringMVC、MyBatis。

1.1 Spring

Spring框架具备IOC/DI、AOP个性。

1.1.1 IOC/DI

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使得我的项目代码的可维护性、可扩展性得以加强。

1.1.2 AOP

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使得代理变得更加简洁、容易。

1.2 SpringMVC

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";
        }
}

1.3 MyBatis

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

2. SpringBoot

在组合应用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>