Springboot和SpringMVC

1.搭建maven

spring直译就是春天的意思，那就是说，有了框架之后就有了春天，是咱们程序员的春天，在以前想要做一个程序，可能需要半年的周期，但是有了框架之后，可能只需要两三个月的时间，大大缩短了开发周期，所以很好用，但是刚开始的时候，想要建立框架就要配置xml文件，但是配置xml文件非常的严格需要有严格的程序，很麻烦，所以现在有了springboot，springboot想要建立框架，需要有jar包，但是还有一个问题是，jar包版本会影响搭建框架，所以要有maven来帮助我们，这样就可以并帮助我们快速的建立一个框架。

 下面我们开始建立启动类

直接新建项目，新建项目的时候左边选择new project，右边起好项目名字，语言选择java，build system选择maven就可以了，

建好项目之后找settings，在settings里面搜索maven ，路径path选择到bin目录之前的文件夹（这个文件是maven文件，需要下载），第一个需要override覆盖，点一下对号之后选择settings配置文件，直接apply然后ok这样就搭建好了环境

在pom.xml文件中加上jar包，可以从网上找然后刷新一下maven就可以了

        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
            <version>2.6.6</version>
        </dependency>

这里用的是下面这个，可以从里面挑选一个使用人多的版本 

在java文件夹下面建包，在包下建立一个application 类，这个类就是启动类，但是需要在类前面加上注解：@springbootapplication，在main方法里面写上springapplication.run(easyspringbootaappliction.class,args);

现在这个application类就是启动类，只要启动这个类，整个项目就会启动

2.ioc控制反转

java类的对象
//在项目运行阶段，项目需要很多对象完成整体业务
// springboot提供了很多注解（@repository（数据访问层），@controller，@bean，@component（其他功能类），@service(业务类),@restcontroller（访问层）），让spring管理这些类的对象的生命周期
//spring提供了ioc（控制反转）的方式方便获取该对象，
//容器和代码之间的控制权反转了，代码中不需要明文获取或者调用方法来得到对象，只需要声明该类需要什么类型的对象即可（标注注解）

@service和restcontroller不同不能替代，想要进入浏览器只能用后者，前者不可以

@autowired

在框架之前，如果我们想要获取一个对象，那我们需要手动获取，而且只有在执行到我们的代码的时候才会获取到，但是springbootico就可以完成反转，只要你声明好了需要获取什么类型的对象就可以了，springboot会给予这个类型的对象，只需要下面这样声明一下就可以了需要有一个@autowired注解，就会给予这个类型的easys对象，

    @autowired
    easyservice easys;

@ requestmapping

@requestmapping这个注解是要与前台进行交互，有了这个注解之后在注解后边加上（"名称"），就可以在浏览器使用http://localhost/8080/名称就可以看到执行的结果；

@restcontroller
public class easycontroller {
    //该类中需要easyservice类的对象
    //就可以在这个类中只需要声明依赖easyservice这个类就可以，不需要通过代码主动获取easyservice类的对象
    //然后只需要一个注解aotuwired
    //通过识别依赖关系，依赖注入（di）对应的对象

    @autowired
    easyservice easys;
    @autowired
    testa testa;
    @requestmapping("testb")
    public  string testb(){
        testa.test();
        return "easy method";
    }}




另外一个类：  @component

public class testa {
 public void test(){
        system.out.println(this);
        system.out.println("test method");
    }
}

 在浏览器上会有easy method，在控制台上会有这个对象，和输出了test method

@bean

不能单独使用，要和@configuration一起使用，这样可以把返回的对象加入到springbean容器里面，方法名就是bean对象的名字

@configuration
public class easyconfig {
    @bean(initmethod = "init")         //里面会有一个方法，
    //@scope("prototype")
    public easybean easybean(){

        return new easybean();
    }
}

@configuration

表示这个类就是一个配置类

spring bean的周期

bean生命周期
    1）根据配置情况调用 bean 构造方法或工厂方法实例化 bean。
    2）利用依赖注入完成 bean 中所有属性值的配置注入。
    3) 如果 bean 实现了 beannameaware 接口，则 spring 调用 bean 的 setbeanname() 方法传入当前 bean 的 id 值。
    4）如果 bean 实现了 beanfactoryaware 接口，则 spring 调用 setbeanfactory() 方法传入当前工厂实例的引用。
    5) 当一个 bean 实现了 applicationcontextaware 接口并在 spring 容器中被实例化时，spring 容器会自动调用该 bean 的 setapplicationcontext 方法，并将应用程序上下文applicationcontext作为参数传递进来
    6）beanpostprocessor 是 spring 框架中的一个重要接口，它允许开发者在 spring 容器创建和初始化 bean 的过程中，对 bean 进行自定义处理。这包括在 bean 实例化之后、属性设置之前（postprocessbeforeinitialization 方法），以及在 bean 初始化之后（postprocessafterinitialization 方法）执行自定义逻辑

spring 容器在创建和初始化每一个 bean 时，都会调用 custombeanpostprocessor 中的这两个方法，允许你进行自定义处理
        在这一步执行的是postprocessbeforeinitialization方法 
    7）initializingbean 是 spring 框架中的一个接口，它定义了一个 afterpropertiesset 方法。当 spring 容器创建 bean 的所有属性都被设置完成后，会调用这个方法。
    8）如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法。
        initmethod指定的方法必须是void类型，并且不接受任何参数
    9）如果 beanpostprocessor 和 bean 关联，则 spring 将调用该接口的初始化方法 postprocessafterinitialization()。此时，bean 已经可以被应用系统使用了。
    10）如果在 <bean> 中指定了该 bean 的作用范围为 scope="singleton"，则将该 bean 放入 spring ioc 的缓存池中，将触发 spring 对该 bean 的生命周期管理；如果在 <bean> 中指定了该 bean 的作用范围为 scope="prototype"，则将该 bean 交给调用者，调用者管理该 bean 的生命周期，spring 不再管理该 bean。
        @scope(scopename =configurablebeanfactory.scope_prototype )
        @scope(scopename =configurablebeanfactory.scope_singleton)
    11）如果 bean 实现了 disposablebean 接口，则 spring 会调用 destory() 方法将 spring 中的 bean 销毁；如果在配置文件中通过 destory-method 属性指定了 bean 的销毁方法，则 spring 将调用该方法对 bean 进行销毁。

@component("easybean")
public class easybean implements beannameaware, beanfactoryaware, applicationcontextaware, initializingbean, disposablebean {
    public void init(){
        system.out.println("init method");
    }
    public easybean(){
        system.out.println("构造方法");
    }
    testa testa;
    @autowired
    public void settesta(testa testa){
        system.out.println("注入属性");
        this.testa=testa;
    }

    public void setbeanname(string name) {

    system.out.println("bean   接口的    beanname方法"+name);
    }
    
    public void setapplicationcontext(applicationcontext applicationcontext) throws beansexception {
        system.out.println("5.-------applicationcontext接口的setapplicationcontext方法"+applicationcontext);
    }
//分别在创建对象
    
    public void afterpropertiesset() throws exception {
        system.out.println("10.     属性设置完毕");
    }
    
    public void destroy() throws exception {
        system.out.println("11   回收销毁");
    }
    
    public void setbeanfactory(beanfactory beanfactory) throws beansexception {
        system.out.println("4.工厂"+beanfactory);
    }
}




@component
public class easy implements beanpostprocessor {


//    public object postprocessbeforeinitialization(object bean, string beanname) throws beansexception {
//
//
//        return beanpostprocessor.super.postprocessbeforeinitialization(bean, beanname);
//    }
//
//    public object postprocessafterinitialization(object bean, string beanname) throws beansexception {
//
//
//        return beanpostprocessor.super.postprocessafterinitialization(bean, beanname);
//    }
}

    了解springbean生命周期的必要性

        pring bean的生命周期定义了从bean的创建、初始化到销毁的一系列过程，以及在这些过程中spring容器如何与bean进行交互
            自定义初始化逻辑：
                通过了解spring bean的生命周期，你可以知道何时是执行自定义初始化逻辑的最佳时机。例如，你可能需要在bean的依赖项注入之后立即进行某些设置或启动某些服务。通过使用@postconstruct注解或者init-method属性，你可以确保这些初始化逻辑在bean的依赖项注入之后执行。
            自定义销毁逻辑：
                同样地，当bean不再需要时，你可能需要执行一些清理操作，如关闭资源连接、释放内存等。通过了解spring bean的生命周期，你可以知道何时是执行这些销毁逻辑的最佳时机。你可以通过实现disposablebean接口或使用@predestroy注解来定义自定义的销毁方法。
            集成第三方库：
                当与第三方库集成时，这些库可能需要在特定的生命周期阶段执行特定的操作。了解spring bean的生命周期可以帮助你确定在何处集成这些库，以确保它们能够正常工作。
            性能优化：
                通过了解spring bean的生命周期，你可以更好地优化你的应用程序的性能。例如，如果你知道某个bean只在特定的请求期间需要，你可以考虑将其声明为作用域为request的bean，这样spring就不会在整个应用程序的生命周期内都持有它的实例。
            调试和排错：
                当应用程序出现问题时，了解spring bean的生命周期可以帮助你更快地定位问题。例如，如果你知道某个bean的初始化方法总是被调用，但某些属性没有被正确设置，那么你可以检查这个初始化方法是否有问题，或者检查是否有其他bean在初始化方法之后修改了这些属性。
            更好的设计决策：
                了解spring bean的生命周期可以帮助你做出更好的设计决策。例如，你可能需要考虑是否将某个功能拆分为多个bean，以及这些bean应该如何相互协作。通过了解生命周期，你可以确定哪些bean应该在其他bean之前或之后创建和销毁。

作用域

使用方法：scope(value="某一作用域")

 //spring  bean（spring管理的对象）的作用域
//singleton  单例模式（默认）
    //prototype   每次需要都会来一个新对象
    //两次打印对象的结果：
//    com.easy.common.testa@1620b463
//test method
//com.easy.common.testa@64655594
//test method
    //request   meb项目中请求作用域，每次请求都会创建一个新对象
//    session会话，一次会话有效时间是30分钟，30分钟之内没请求会自动断开会话，安全退出也会断开会话，一次会话都会创建一个新的对象，管理员让用户下线
    //globalsession   全局的
 

3.springmvc

springmvc是基于mvc概念写好一个框架，我们来用，并不是写mvc

@restcontroller和@controller不一样，后者如果返回的是一个字符串，会把字符串解析成地址，前者不会

做mvc的时候需要thymeleaf（前端架构）依赖（spring-boot-starter-thymeleaf），也是从网络上下载，在resourse文件下创建文件夹templates，在这个文件夹下面创建html文件然后加上引入

要记住刷新maven！！！！

然后再编写html文件 

@controller
public class easybcontroller {
    @requestmapping("testm")
    public modelandview testm(){
    modelandview mav=new modelandview();
    mav.setviewname("index");
    mav.addobject("username","张三");
        return  mav;
    }
}

html文件：

<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="utf-8">
    <title>title</title>
</head>
<body>
index page
<h1 th:text="${username}">hello, world!</h1>
</body>
</html>