【Spring基础】Spring从入门就没有放弃

一些术语的定义

POJO

“Plain Ordinary Java Object”，简单普通的java对象。没有从任何类继承、也没有实现任何接口，更没有被其它框架侵入的java对象。
比如：

public class HelloWorld {
    private String message;
    public void setMessage(String message){
        this.message  = message;
    }
    public void getMessage(){
        System.out.println("Your Message : " + message);
    }
}

而不是
1、继承预先设定的类，如：

public class Foo extends javax.servlet.http.HttpServlet { 
    // ...
}

2、实现预先设定的接口，如：

public class Bar implements javax.ejb.EntityBean { 
    // ...
}

3、包含预先指定的注解，如：

@javax.persistence.Entity
public class Baz { 
    // ...
}

JavaBean

JavaBean 是一种JAVA语言写成的可重用组件。JavaBean符合一定规范编写的Java类，不是一种技术，而是一种规范。JavaBean是一个可序列化的POJO，具有一个无参构造器，并且允许使用遵循简单命名约定的getter和setter方法来访问属性。
规范：
1、所有属性为private。

2、这个类必须有一个公共的缺省构造函数。即是提供无参数的构造器。

3、这个类的属性使用getter和setter来访问，其他方法遵从标准命名规范。

4、这个类应是可序列化的。实现serializable接口。

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

  public void setName(String name) {
    this.name = name;
  }
  public String getName() {
    return name;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public int getAge() {
    return age;
  }

}

他用在什么地方呢，比如：有个Student类（也就是javabean），有name，age两个属性，数据库中也存放着一个Student表，其中的列分别是name，age。那么当我们从数据库中取了一行数据时，应该如何放置到java中来进行后续的处理呢，很显然我们可以把javabean当作一个接受类型，来存放数据库中取出的那一行值，因为数据库中的数据正好和javabean是一样的。同样的，我们可以把一个javabean的类型忘数据库里放。这样就可以很方便的和底层交互了。

EJB

官方说法是：商务软件的核心部分是它的业务逻辑。业务逻辑抽象了整个商务过程的流程，并使用计算机语言将他们实现。
变成大白话就是，“把你编写的软件中那些需要执行制定的任务的类，不放到客户端软件上了，而是给他打成包放到一个服务器上了”。
具体可参考：https://www.cnblogs.com/strugglion/p/6027318.html
看完这篇文章，我算是明白了EJB的概念和作用了。
首先J2EE 将业务逻辑（执行特定任务的"类"，从后端开发的角度，我理解就是服务）从客户端软件中抽取出来，封装在一个组件中。这个组件运行在一个独立的服务器上，客户端软件通过网络调用组件提供的服务以实现业务逻辑，而客户端软件的功能单纯到只负责发送调用请求和显示处理结果。对照下面的图就可以充分理解了。
在Java中，能够实现远程对象调用的技术是RMI，而EJB 技术基础正是RMI（远程方法调用，也就是一台机器调用另一台机器的方法或者函数）。

J2EE

目前，Java 2平台有3个版本，它们是适用于小型设备和智能卡的Java 2平台Micro版（Java 2 Platform Micro Edition，J2ME）、适用于桌面系统的Java 2平台标准版（Java 2 Platform Standard Edition，J2SE）、适用于创建服务器应用程序和服务的Java 2平台企业版（Java 2 Platform Enterprise Edition，J2EE）。
J2EE是一种利用Java 2平台来简化企业解决方案的开发、部署和管理相关的复杂问题的体系结构。

1、应用客户端程序和applets是客户层组件
2、Java Servlet和JavaServer Pages(JSP)是web层组件
3、Enterprise JavaBeans(EJB)是业务层组件
引自
https://www.jianshu.com/p/6f3e2bd50cb1
https://www.jianshu.com/p/224489dfdec8

为什么要使用Spring

刚毕业的时候就接触到了Spring，到现在还是对它一知半解，所以决定开始真正的学习Spring。
Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。
简单来说，Spring就是为了简化Java开发的，但是Spring如何简化Java开发的呢？
很多资料说的都是以下四点：
1、基于POJO的轻量性和最小侵入性编程

2、通过依赖注入和面向接口实现松耦合

3、基于切面和惯例进行声明式编程

4、通过切面和模板减少样板式代码

但是光看这简单的描述，很难理解，我们一个一个的来。
引自：https://baijiahao.baidu.com/sid=1631400273152918031&wfr=spider&for=pc
1、基于POJO的轻量性和最小侵入性编程
根据这篇文章，我写了一个类似的例子。
来看看传统代码，现在有一家汽车店，店里面有两种车：奔驰和凯迪拉克。

public class AutoShop {
    private static List<String> list = new ArrayList<>();
    static {
        list.add("奔驰");
        list.add("凯迪拉克");
    }
    public void carList(){
        System.out.println("汽车店里有这些车："+list);
    }
}

我想买车的话，就要继承父类，也就是汽车店。

public class Buy extends AutoShop {
    public static void main(String[] args) {
        Buy buy = new Buy();
        buy.carList();
    }
}

代码看上去没什么问题，但是现在汽车店想要增加一个功能，我们就需要在父类增加功能，然后子类也要维护。
再来看看Spring，从代码结构上就可以看出减轻了父子类之间的一来关系。

public class AutoShop {
    private static List<String> list = new ArrayList<>();

    static {
        list.add("奔驰");
        list.add("凯迪拉克");
    }

    public void carList() {
        System.out.println("汽车店里有这些车：" + list);
    }

}

public class Buy {
    private AutoShop autoShop;

    public Buy(AutoShop autoShop) {
        this.autoShop = autoShop;
    }

    public void getList() {
        autoShop.carList();
    }
}

@Configuration
public class BeaConfig {

    @Bean
    public AutoShop getAutoShop() {
        return new AutoShop();
    }

    @Bean
    public Buy getBuy() {
        return new Buy(getAutoShop());
    }
}

public class test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext apc = new AnnotationConfigApplicationContext(BeaConfig.class);
        Buy buy = apc.getBean(Buy.class);
        buy.getList();
    }
}

2、通过依赖注入和面向接口实现松耦合
任何一个有实际意义的应用，都会由很多个类组成，这些类相互协作来完成特定的任 务。 如果每个对象都负责管理与自己相互协作的对象，这会导致应用高度耦合。
假设现在又有一家汽车店，我们应该怎么做？

public class AutoShop1 {
    private static List<String> list = new ArrayList<>();

    static {
        list.add("奔驰_1");
        list.add("凯迪拉克_1");
    }

    public void carList() {
        System.out.println("第一家汽车店里有这些车：" + list);
    }

}

public class AutoShop2 {
    private static List<String> list = new ArrayList<>();

    static {
        list.add("奔驰_2");
        list.add("凯迪拉克_2");
    }

    public void carList() {
        System.out.println("第二家汽车店里有这些车：" + list);
    }

}

public class Buy {
    private AutoShop1 autoShop1;
    private AutoShop2 autoShop2;

    public Buy(AutoShop1 autoShop1, AutoShop2 autoShop2) {
        this.autoShop1 = autoShop1;
        this.autoShop2 = autoShop2;
    }

    public void getList() {
        autoShop1.carList();
        autoShop2.carList();
    }
}

@Configuration
public class BeaConfig {
    @Bean
    public AutoShop1 getAutoShop1() {
        return new AutoShop1();
    }

    @Bean
    public AutoShop2 getAutoShop2() {
        return new AutoShop2();
    }

    @Bean
    public Buy Buy() {
        return new Buy(getAutoShop1(), getAutoShop2());
    }
}

public class test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext apc = new AnnotationConfigApplicationContext(BeaConfig.class);
        Buy buy = apc.getBean(Buy.class);
        buy.getList();
    }
}

3、基于切面和惯例进行声明式编程
切面编程允许你把遍布在应用各处的功能分离出来形成可重用的组件（例如：常见的日志、事物）。
传统代码

public class AspectUtils {
    public static void say() {
        System.out.println("进入可执行方法。。。");
    }
}

public class AopTest1 {
    public static void main(String[] args) {
        AspectUtils.say();
        System.out.println("传统编程！！！");
    }
}

现在有一个AopTest2，那么还需要将AspectUtils.say();这句话加入 到相应的方法中，很麻烦、而且后期如果修改了方法、那简直就是厄运了。
Aop（面向切面编程）可以解决这个问题

public class AopTest1 {
    public void test() {
        System.out.println("Aop编程1！！！");
    }
}

public class AopTest2 {
    public void test() {
        System.out.println("Aop编程2！！！");
    }
}

构建一个切片类，添加切入点，配置前调用say()

@Aspect
@Component
public class AspectUtils {

    @Pointcut("execution(* com.zhudan.test1.demo5.AopTest1.*(..))")
    public void expression() {
    }
    @Pointcut("execution(* com.zhudan.test1.demo5.AopTest2.*(..))")
    public void expression2() {
    }
    @Before("expression(),expression2()")
    public void say() {
        System.out.println("进入可执行方法。。。");
    }
}

配置好bean之后就可以使用了

@Configuration
@EnableAspectJAutoProxy
public class AspectConfig {
    @Bean
    public AspectUtils getAspectUtils(){
        return new AspectUtils();
    }
    @Bean
    public AopTest1 getAopTest1(){
        return new AopTest1();
    }
    @Bean
    public AopTest2 getAopTest2(){
        return new AopTest2();
    }
}

测试一下

public class test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext apc = new AnnotationConfigApplicationContext(AspectConfig.class);
        AopTest1 aopTest1 = apc.getBean(AopTest1.class);
        aopTest1.test();
        AopTest2 aopTest2 = apc.getBean(AopTest2.class);
        aopTest2.test();
    }
}

4、通过切面和模板减少样板式代码
相信大家都使用过JDBC编程，里面的样板式代码就不用说了，什么连接呀、什么最后关闭呀，都是一致的。你会发现你要实现的业务层就那么一点，而你的代码却很长，而且还是和你业务没有什么关系的代码、spring为我们提供了JdbcTemplate来 消除样板式代码，并且spring也集成了Hibernate、mybatis。以及JPA来简化我们的开发。
说到Java 开发，涉及到数据库访问的，主要就两种框架，一个是 MyBatis ，另一个就是 JPA。我曾经在半知半解的情况下，用了这两种，一开始不知道行情，用了JPA，但是后来领导说不要用JPA。现在才明白JPA就是让你尽量少些或者不写sql语句，但是一旦要写的话，除了要掌握各种注解外，对于稍微复杂的查询，还要掌握它的那套写法。