简单认识框架

hi,大家好,好久不见今天为大家带来框架相关的知识

1.框架

1.1为什么要学习框架

之前的学习我们都没有接触过框架,所有的代码都需要我们自己写,而有了框架,我们只需要写部分代码,框架更加易用简单高效

2.框架的优点

我们先采用SpringBoot和Servlet来对比
使用SpringBoot项目演示框架相对于使用servlet具有的优点
1.不用配置Tomcat,点击运行就行,因为Spring Boot内置了Tomcat
2.可以快速添加jar包(不用再到中央仓库复制粘贴)
3.快速发布项目(采用java -jar)就能发布
4.对象自动装配
还有很多优点,我们之后会进行详细的讲解,今天就先简单心里有个数

2.1采用servlet创建项目

我们之前以及学习过了servle项目的创建
步骤为以下七步
1.创建项目
2.引入依赖
3.创建目录
4.编写代码
5.打包程序
6.部署程序
7.验证程序
具体内容详见链接: http://t.csdn.cn/h9Xs8

2.1.1缺陷

我们由上述步骤可以看到很繁琐,

1. 添加外部 jar 不⽅便，容易出错，⽐如添加了⼀个不匹配的外部 jar 版本；
2. 运⾏和调试的时候需要配置 tomcat 不⽅便；
3. 发布不⽅便，servlet 项⽬必须依靠外置的 tomcat（外置的 web 容器）运⾏。
4. 路由配置不⽅便，⼀个访问地址对应⼀个 Servlet 类。
   但是采用springboot可以解决这些问题

2.2采用SpringBoot创建项目

我们现在就来创建一个springboot项目让大家来感受一下
我们就先不详细介绍创建springboot的创建步骤了,后面再详细说

这个就是当一个springboot项目创建好以后展示的画面,我们在绿色的Java中创建一个TestController类

package com.example.demo;

import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller //当前类为控制器
@ResponseBody //返回的是数据,而非页面
public class TestController {

    @RequestMapping("/hi") //url 路由
    public String shaHi(String name) {
      
        if (!StringUtils.hasLength(name)) {
            name = "张三";
        }
        return "你好:" + name;
    }

}

要怎么运行呢,非常简单,点击三角符号,就可以运行了

上浏览器查看是否验证是否成功

成功了!

2.2.1优势

1.调试项⽬更加⽅便，⽆需配置 Tomcat
2.添加外部 jar 更容易，不易出错（版本问题⽆关注）
3.发布项⽬更加⽅便，⽆需配置 Tomcat
4.添加路由更加⽅便，⽆需每个访问地址都添加⼀个类,servlet是一个类对应一个URL,而springboot是一个方法对应一个URL

3.Spring是什么

Spring是Spring Framework(Spring框架),这是一个开源框架
一句话来说,Spring是包含了众多工具方法的IOC容器
什么是容器?什么是IOC?什么是IOC容器?

3.1 容器

容器是容纳物品的装置容器还是很通俗易懂的嘛,我们之前其实学过一些容器,数据结构里的List,Map,这些属于数据存储容器,还有Tomcat也会容器,属于Web容器

3.2 Ioc

Inversion of Control,控制权反转
即对象的生命周期不由程序员/代码控制,而是由Spring(ioc容器)控制

3.3 IOC容器

IOC容器就是控制权反转容器,以前使用对象要new,现在不用new了,只需要去spring(IOC容器)中去取,拿过来直接用

代码理解IOC和传统开发的区别

我们就拿造一台车来举例

这几个部件存在依赖关系
写代码

public class Car {
    private Framework framework;
    public Car(){
        this.framework=new Framework();
    }
    public void init(){
        System.out.println("执行Car的init方法");
        framework.init();
    }
}

public class Framework {
    private Bottom bottom;
    public Framework(){
        this.bottom=new Bottom();

    }
    public void init(){
        System.out.println("执行Frameworkd的方法");
        bottom.init();
    }
}

public class Bottom {
    private Tire tire;
    public Bottom(){
        this.tire=new Tire();
    }
    public  void init(){
        System.out.println("执行Bottom的init方法");
        tire.init();
    }
}

public class Tire {
    public int size=10;
    public Tire(){

    }
    public void init(){
        System.out.println("执行tire方法 size"+size);

    }
}

public class Test {
    public static void main(String[] args) {
        Car  car=new Car();
        car.init();
    }
}

执行结果

当轮胎尺寸变化,比如要变成30,每一个代码都要改

public class Tire {
    public int size=10;
    public Tire(int size){
        this.size=size;
    }
    public void init(){
        System.out.println("执行tire方法 size"+size);

    }
}

public class Bottom {
    private Tire tire;
    public Bottom(int size){
        this.tire=new Tire(size);
    }
    public  void init(){
        System.out.println("执行Bottom的init方法");
        tire.init();
    }
}

public class Framework {
    private Bottom bottom;
    public Framework(int size){
        this.bottom=new Bottom(size);

    }
    public void init(){
        System.out.println("执行Frameworkd的方法");
        bottom.init();
    }
}

public class Car {
    private Framework framework;
    public Car(int size){
        this.framework=new Framework(size);
    }
    public void init(){
        System.out.println("执行Car的init方法");
        framework.init();
    }
}

public class Test {
    public static void main(String[] args) {
        Car  car=new Car(30);
        car.init();
    }
}

我们只是对Tire类里的构造方法加了一个属性,就会导致所有代码都出现问题,这就是牵一发而动全身,代码的耦合性太高了,那么我们采用IOC容器来解决这个问题

public class Car {
    private Framework framework;
    public Car(Framework framework){
        this.framework = framework;
//        framework = new Framework();
    }
    public void init(){
        System.out.println("Car init");
        framework.init();
    }
}

public class Framework {
    private Bottom bottom;
    public Framework(Bottom bottom){
        this.bottom = bottom;
    }
    public void init(){
        System.out.println("Framework init");
        bottom.init();
    }
}

public class Bottom {
    private Tire tire;
    public Bottom(Tire tire){
        this.tire = tire;
    }
    public void init(){
        System.out.println("Bottom init");
        tire.init();
    }
}

public class Tire {
    private int size = 15;
    public Tire(int size){
        this.size = size;
    }
    public void init(){
        System.out.println("Tire init, Size:"+size);
    }
}

public class Test {
    private Tire tire;
    private Bottom bottom;
    private Framework framework;
    private Car car;
    public Test(){
        this.tire = new Tire(12);
        this.bottom = new Bottom(this.tire);
        this.framework = new Framework(this.bottom );
        this.car = new Car(this.framework);
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.car.init();
    }
}

我再想修改我就在IOC容器里面修改,和那些调用代码无关,我只是调用你,我不管你内部的属性啊啥的,与我无瓜~~~

总结:IOC优点
1.控制权反转:对象的生命周期由spring(IOC容器)控制,不由代码或者程序员控制
2.实现解耦(松耦合),就拿这个车的例子可以看出
今天的讲解就到此结束,我们下期再见,886~~