Java SSM学习（一）

        首先学习Java SSM之前，需要先对Java，Java SE，java web先要有一定的学习基础，然后再来学习Java SSM。

        此文章是本人学习笔记，也是学习网上大佬的才稍微总结出来，便于自己的理解和回顾，如果可以帮助到正在学习Java SSM的人自然很好，有引用到的文章，在参考博文中均已注明。

       SSM（Spring+SpringMVC+Mybatis），这个也是开始接触到框架，可以更加高效的完成任务。在Java web的时候，大家也已经可以搭建网站，编写小项目，但是相应的，需要写很多的接口，对象，这些都是很繁琐的，开发或者修改的效率大大减低，框架的学习就可以规范我们编写代码的格式和提高我们的效率。

一，Spring的学习

Spring框架主要就是基础的Java开发进行了包装整合，只需要少量的代码和一些配置就可以完成Java项目的开发，减少Java web的代码量和工作时间。

Spring是一个轻量级的控制反转(IOC)和面向切面(AOP)的容器框架。

Spring的学习主要分为：

        1，学习JavaBean

        2，学习IOC

        3，学习AOP

        4，学习使用注解对项目的开发

1，学习JavaBean

        JavaBean的含义就是具有一定规范的实体类，必须具有一个无参的构造函数，它的属性是私有的（private），需要访问javaBean就需要使用get/set方法，如下一个Student类所示：

public class Student {
    private String name;
    private int age;

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

2，学习IOC

       （1）初步认识IOC

        IOC为控制反转，在原来程序的运行，需要各个部分合作完成，就像一组彼此紧密相连的齿轮，缺一不可，比如，要实现一个查询课表的命令，那么首先需要使用Servlet进行请求和响应的数据处理，然后请求的数据全部交给对应的Service来处理，当Service发现要从数据库中获取数据时，再向对应的Mapper发起请求。如下图所示：

        这样虽然使得程序可以更加直观，但是同样修改的时候麻烦也是成倍的增加，于是我们就要使用IOC，IOC的目的就是‘解耦’。使得各个部分分散开来，使得整个系统变得灵活起来，可以被重用，或者扩展。如下图所示。

         我们可以将对象交给IOC容器进行管理，需要接口，我们就可以根据配置文件来决定实现类，因为定义了接口，所以我们只用调用就行，就像那个大佬博主说的，这样我们写项目的时候就可以让一个人去写视图层，一个人写业务层，开发效率大大提升。不得不说，他解释的特别清楚。

        现在大概了解IOC就可以开始写项目了，第一步我们主要学习的就是配置文件的使用。

      （2）  第一个Spring项目

        首先，写Spring项目需要在pom.xml文件中导入Spring依赖：

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.22</version>
    </dependency>
  </dependencies>

        随便写一个Student类，和上面一样：

public class Student {
    private String name;
    private int age;
}

        然后，接着在resource中创建一个Spring配置文件，命名为Spring.xml，记得点击配置上下文，在xml内写下如下代码，其中name属性，全局唯一，不可出现重复的名称，class为Student的地址；

<bean name="student" class="Student"/>

        最后在主方法中写：

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student);

        这样就写出了一个最简单的Spring的项目，实现了由IOC来管理对象。

        （3）Bean的属性

        我们都知道，在配置文件中的bean，除了最常见的id（和name一样），class，它还具有多个属性：

        scope：它有多个值，我只解释重要的的两个值，

                singleton：默认值，单例模式

                prototype：多例模式

                这两个模式的生命周期也是很有意思，处于单例模式，那么它会在一开始就被创建，处于原型模式下，只有在获取时才会被创建，如果大家想更加进一步的了解也可以查看别的文章。

        （4）依赖注入

        依赖注入也就是为Bean成员进行赋值的操作，我们可以使用property标签，将预先设定好的属性注入在对象之中，如下所示：

<bean name="student" class="Student">
                <property name="name" value="张三"/>
                <property name="age" value="18"/>
</bean>

  

public class Student {
    private String name;
    private int age;

    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 void say(){
        System.out.println("我是："+name+"我今年"+age+"岁了！");
    }
}

         最后，在主方法之中进行测试：

  public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Student student = (Student) context.getBean("student");
        student.say();
    }

          成功输出结果：

​

         如果注入类型为集合或者为Map类型，我们可以使用<list>和<map>。

3，学习Aop

       （1）认识AOP

        AOP也就是面向切面编程，也是面向对象编程的补充和完善，它的作用简而言之就是，在一段程序运行之中，我们可以使用AOP在方法执行的前后做一些额外的操作。它的实际原理就是动态代理机制实现的，我们这里直接用AOP，因为AOP做了很多封装，只要调用API即可，简化开发。

        （2）进一步学习，使用AOP

        AOP的使用也需要导入依赖，和之前Spring的依赖导入方式一样。

  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>xml

        首先，我们需要写一个类，就使用上文的Student就可以

        然后，我们希望在say方法执行的前后插入我们想额外执行的命令，于是：

public class Aop {
    //执行之前的方法
    public void before(){
        System.out.println("执行之前");
    }

    //执行之后的方法
    public void after(){
        System.out.println("执行之后");
    }
}

        当然，只是写好额外的内容是不行的，我们还需要告诉Spring，我们需要在方法执行之前和之后对其插入这些额外的命令，然后我们就需要将AOP的操作类注册为Bean:

        <bean name="student" class="Student"/>
        <bean name="aop" class="Aop"/>

        以上为两个类，一个Student和一个Aop类，然后我们需要在Spring.xml之中进行一些修改，要引入Aop的相关标签：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

         这样就可以实现Aop的功能，然后再配置文件之中添加Aop的配置：

<aop:config>
        <aop:pointcut id="test" expression="execution(* Student.test(String))"/>

        <aop:aspect ref="aop">
                <aop:before method="before" pointcut-ref="test"/>
                <aop:after-returning method="after" pointcut-ref="test"/>
        </aop:aspect>
</aop:config>

        我们为其添加了执行前的动作和执行后的动作，最后主方法：

    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("Spring.xml");
        Student student = (Student) context.getBean("student");
        student.test("执行方法！！！");
    }

        这样就完成了全部的配置，得到结果：

        最后，我们可以为我们切入的方法添加一个参数，通过此参数就可以快速获取切点位置的一些参数信息，比如，获取执行方法的对象，获取传入方法的实参等。

4， 学习使用注解对项目的开发

        上文我们学习了使用配置文件来实现Spring的方法，我们也看到了他的一些缺点，编写的内容过于繁琐，所以，我们又引入了一种新的方法，使用注解的方法来替换配置文件，”白学“。

        （1）注解实现配置文件

        学习注解的第一步就是删除resources文件夹之下的XML文件，我们现在不使用XML文件，开始逐步引入注解。

        首先，我们需要使用实体类来代替配置文件，我们创建Spring.class文件，然后只用加入@Configuration注解：

@Configuration
public class Spring {
}

        这样就可以等价替换了resources文件夹之下的Spring.xml文件。

        然后，我们直接在配置文件之中编写Bean的信息，写Student方法，只需要加上@Bean注解：

    @Bean
    public Student student(){
        return new Student();
    }

        这样就等价于：

   <bean name="student" class="Student"/>

        我们还可以继续添加@Scope注解来指定作用域，可以指定单例模型和原型模型。

        最后，我们需要在主方法之中加载配置类，创建容器：

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Spring.class);
        Student student = (Student) context.getBean("student");
        System.out.println(student.say("执行了方法"));
    }

        @ComponentScan注解可以进行包扫描的操作。 

        （2）使用注解进行注入

        首先，希望Spring自动将其注入到Student的属性中，同样将Card也注册为一个Bean：

@Component
public class Student {
    String name;
    int sid;
    Card card;
}

@Component
@Scope("prototype")
public class Card {
}

         然后，我们将Card使用@Resource进行自动装配：

@Component
public class Student {
    String name;
    int sid;
    
    @Resource
    Card card;
}

  @Resource以外，我们还可以使用@Autowired。

（3）注解实现AOP

        首先，我们需要在主类添加@EnableAspectJAutoProxy注解，开启AOP注解支持：

@Configuration
@EnableAspectJAutoProxy
@ComponentScan("com.spring.bean")
public class Spring {

}

        然后，我们需要在Aop操作类之上添加@Aspect和@Component注解：

@Component
@Aspect
public class Aop {

}

        例如，我们想要插入before操作，我们只需要添加@Before注解，然后后面填写想要插入方法的地址，括号之中”..“通配符，不用自己写类型。

   @Before("execution(* com.spring.bean.Student.say(..))")
public void before(){
    System.out.println("我是之前执行的内容！");
}

        最终，可以实现Aop的操作，同样的也可以实现After的方法，只用使用@AfterReturning的注解就可以实现操作。

---

        Spring的基础知识大致就这样，后续的MyBatis和SpringMVC我会很快整理出来。