今天尝试搭建一个ssm框架：

首先在数据库当中创建了表：

之后在idea当中创建实体类：

public class Pc {

    private int id;
    private String name;
    private int age;
    private String type;
    private String sex;
    private String school;


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }
}

创建DAO类：

//指定仓库
@Repository("pcDao")
public interface PcDao {


    //查询数据信息列表
    public  List<Pc>selectUserByUname(Pc pc);
}

定义Service类

public interface PcService {


    List<Pc> selectUserByUname(Pc pc);
}

//标记这个类为spring容器的bean
@Component("PcService")
public class PcServiceImpl implements PcService {

    //自动装配
    @Autowired
    private PcDao pcDao;


    //方法重写
    @Override
    public List<Pc> selectUserByUname(Pc pc) {
        return pcDao.selectUserByUname(pc);
    }
}

创建一个控制类：

package com.weixiao.controller;

import com.weixiao.Pc;
import com.weixiao.Service.PcService;
import com.weixiao.dao.PcDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

public class PcController {
    //自动配装
    @Autowired
    private PcService pcService;

    @RequestMapping("/select")
    public String Select(Pc pc , Model model){
        List<Pc> list = pcService.selectUserByUname(pc);
        model.addAttribute("pcList".list);
        return "pcList";

    }

}

遇到的难题：发现有着很多的注释代码还需要巩固学习的。

去查找了一些相关的学习资料

model.addattribute(K,V)往前台传数据，可以传对象，可以传List，通过el表达式 ${}可以获取到

Spring常用注解

在具体介绍IoC和AOP之前，我们先简要说明下Spring常用注解

1、@Controller：用于标注控制器层组件

2、@Service：用于标注业务层组件

3、@Component : 用于标注这是一个受 Spring 管理的组件，组件引用名称是类名，第一个字母小写。

可以使用@Component(“beanID”) 指定组件的名称

4、@Repository：用于标注数据访问组件，即DAO组件

5、@Bean：方法级别的注解，主要用在@Configuration和@Component注解的类里，@Bean注解的方法会产生一个Bean对象，

该对象由Spring管理并放到IoC容器中。引用名称是方法名，也可以用@Bean(name = "beanID")指定组件名

6、@Scope("prototype")：将组件的范围设置为原型的（即多例）。保证每一个请求有一个单独的action来处理，避免action的线程问题。

由于Spring默认是单例的，只会创建一个action对象，每次访问都是同一个对象，容易产生并发问题，数据不安全。

7、@Autowired：默认按类型进行自动装配。在容器查找匹配的Bean，当有且仅有一个匹配的Bean时，Spring将其注入@Autowired标注的变量中。

8、@Resource：默认按名称进行自动装配，当找不到与名称匹配的Bean时会按类型装配

spring ioc：控制反转就是将控制权反转到了spring框架上

通常，我们实例化一个对象时，都是使用类的构造方法来new一个对象，这个过程是由我们自己来控制的，而控制反转就把new对象的工交给了Spring容器。

IoC容器：具有依赖注入功能的容器，可以创建对象的容器。IoC容器负责实例化、定位、配置应用程序中的对象并建立这些对象之间的依赖。

面向切面编程(AOP)

面向切面编程（AOP）就是纵向的编程。比如业务A和业务B现在需要一个相同的操作，

传统方法我们可能需要在A、B中都加入相关操作代码，而应用AOP就可以只写一遍代码，A、B共用这段代码。并且，当A、B需要增加新的操作时，

可以在不改动原代码的情况下，灵活添加新的业务逻辑实现。

在实际开发中，比如商品查询、促销查询等业务，都需要记录日志、异常处理等操作，AOP把所有共用代码都剥离出来，

单独放置到某个类中进行集中管理，在具体运行时，由容器进行动态织入这些公共代码。

AOP主要一般应用于签名验签、参数校验、日志记录、事务控制、权限控制、性能统计、异常处理等。

AOP涉及名词

切面（Aspect）：共有功能的实现。如日志切面、权限切面、验签切面等。

在实际开发中通常是一个存放共有功能实现的标准Java类。当Java类使用了@Aspect注解修饰时，就能被AOP容器识别为切面。

通知（Advice）：切面的具体实现。就是要给目标对象织入的事情。以目标方法为参照点，根据放置的地方不同，

可分为前置通知（Before）、后置通知（AfterReturning）、异常通知（AfterThrowing）、最终通知（After）与环绕通知（Around）5种。

在实际开发中通常是切面类中的一个方法，具体属于哪类通知，通过方法上的注解区分。

连接点（JoinPoint）：程序在运行过程中能够插入切面的地点。例如，方法调用、异常抛出等。

Spring只支持方法级的连接点。一个类的所有方法前、后、抛出异常时等都是连接点。

切入点（Pointcut）：用于定义通知应该切入到哪些连接点上。

不同的通知通常需要切入到不同的连接点上，这种精准的匹配是由切入点的正则表达式来定义的。

比如，在上面所说的连接点的基础上，来定义切入点。我们有一个类，类里有10个方法，那就产生了几十个连接点。

但是我们并不想在所有方法上都织入通知，我们只想让其中的几个方法，在调用之前检验下入参是否合法，那么就用切点来定义这几个方法，让切点来筛选连接点，选中我们想要的方法。切入点就是来定义哪些类里面的哪些方法会得到通知。

目标对象（Target）：那些即将切入切面的对象，也就是那些被通知的对象。

这些对象专注业务本身的逻辑，所有的共有功能等待AOP容器的切入。

代理对象（Proxy）：将通知应用到目标对象之后被动态创建的对象。可以简单地理解为，代理对象的功能等于目标对象本身业务逻辑加上共有功能。

代理对象对于使用者而言是透明的，是程序运行过程中的产物。目标对象被织入共有功能后产生的对象。

织入（Weaving）：将切面应用到目标对象从而创建一个新的代理对象的过程。这个过程可以发生在编译时、类加载时、运行时。Spring是在运行时完成织入，运行时织入通过Java语言的反射机制与动态代理机制来动态实现。

通过学习spring Ioc和springaop得到的小结：

   spring Ioc（控制反转）简单的来说就是我们new了一个对象之后，不需要人为的控制，有spring容器来控制。

   spring Aop（面向切面编程）：

    面向切面编程能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，

    便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

Spring bean是Spring框架在运行时管理的对象。Spring bean是任何Spring应用程序的基本构建块

Spring bean的管理包括：

• 创建一个对象
• 提供依赖项（例如其他bean，配置属性）
• 拦截对象方法调用以提供额外的框架功能
• 销毁一个对象

@Configuration注解标识的类中声明了1个或者多个@Bean方法

Component 和 @Bean 的区别是什么？

@Component 注解作用于类，而@Bean注解作用于方法。

@Component通常是通过类路径扫描来自动侦测以及自动装配到 Spring 容器中

（我们可以使用 @ComponentScan 注解定义要扫描的路径从中找出标识了需要装配的类自动装配到 Spring 的 bean 容器中）。

@Bean 注解通常是我们在标有该注解的方法中定义产生这个 bean,@Bean告诉了 Spring 这是某个类的实例，当我需要用它的时候还给我。

@Bean 注解比 @Component 注解的自定义性更强，而且很多地方我们只能通过 @Bean 注解来注册 bean。

比如当我们引用第三方库中的类需要装配到 Spring容器时，则只能通过 @Bean来实现。

示例：

@Configuration

public class AppConfig {

    @Bean

    public TransferService transferService() {

        return new TransferServiceImpl();

    }

}

上面的这段示例代码相当于下面的xml配置：

<beans>

    <bean id="transferService" class="com.acme.TransferServiceImpl"/>

</beans>

查询spring的基础，巩固了spring ioc spring aop的核心思想