javaweb笔记（下（原理篇+maven高级））

Spring Boot 是一个用于快速创建基于 Spring 框架的 Java 项目的工具，它极大地简化了依赖管理和项目配置。它的底层原理主要包括以下几个方面：

1. **依赖管理**：Spring Boot 提供了一个特殊的 `spring-boot-starter-parent` 父 POM，它集成了许多常用的依赖库，使得开发者无需手动指定依赖版本。此外，通过提供一系列的 `spring-boot-starter-*` 依赖，你可以轻松地将所需的组件添加到项目中。

2. **自动配置**：Spring Boot 的另一个核心功能是自动配置。通过扫描类路径中的 JAR 包并检查配置文件，Spring Boot 可以自动配置许多常用的 Spring 应用程序组件，如数据源、Web 服务器、安全设置等。这极大地简化了开发者的工作，让我们可以专注于业务逻辑的实现。

3. **嵌入式容器**：Spring Boot 内置了多种嵌入式容器，如 Tomcat、Jetty 和 Undertow。这意味着你不再需要独立部署应用程序到外部容器，而是可以将应用程序打包成一个可执行的 JAR 文件。这使得部署过程更加简单，同时也降低了运维成本。

4. **生产环境支持**：Spring Boot 提供了一套生产级的服务监控和管理功能，如健康检查、度量指标、外部配置等。这些功能可以帮助你更好地监控和管理应用程序，确保其稳定运行。

5. **简化开发过程**：Spring Boot 提供了一系列的插件和工具，如 Spring Boot Actuator、Spring Boot DevTools 和 Spring Boot Test，以简化开发、测试和运维过程。

总之，Spring Boot 的底层原理主要是通过依赖管理、自动配置、嵌入式容器和生产环境支持等功能，来简化 Java 开发者基于 Spring 框架创建、开发和部署项目的过程。

---黑马）↓

配置的优先级

application. properties  >   application.yml  >  application.yaml

 

命令行参数   >  系统属性

 

 

 bean的管理

获取bean

    //获取bean对象
    @Test
    public void testGetBean(){
        //根据bean的名称获取
        DeptController bean1 = (DeptController) applicationContext.getBean("deptController");//声明的bean对象没有指定名称默认小写类名
        System.out.println(bean1);

        //根据bean的类型获取
        DeptController bean2 = applicationContext.getBean(DeptController.class);
        System.out.println(bean2);

        //根据bean的名称 及 类型获取
        DeptController bean3 = applicationContext.getBean("deptController", DeptController.class);
        System.out.println(bean3);
    }

 原来因为一开始就配置了↓

bean的作用域

 

 @Lazy

//（延迟初始化）在这个bean第一次使用的时候才实例化（默认启动时初始化）

@Scope("prototype")

// 每一次使用bean的时候都会创建一个新的（默认是单例模式）

第三方bean

 

//仰晨study 创建时间2023/4/26 1:05 星期三
package com.itheima.config;

import org.dom4j.io.SAXReader;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration  //配置类
public class commonConfig {
    //声明第三方的bean
    @Bean//将当前方法的返回值对象交给IOC容器管理，成为IOC容器bean
        //通过@Bean注解的name/value属性指定bean名称，如果未指定，默认是方法名:ikun(演示更直观｝一般还是类名首字母小写sAXReader
    public SAXReader ikun() {
        return new SAXReader();
    }
}

    @Autowired
    private SAXReader saxReader;
    
    //第三方bean的管理
    @Test
    public void testThirdBean() throws Exception {
        //SAXReader saxReader = new SAXReader();

        Document document = saxReader.read(this.getClass().getClassLoader().getResource("1.xml"));
        Element rootElement = document.getRootElement();
        String name = rootElement.element("name").getText();
        String age = rootElement.element("age").getText();

        System.out.println(name + " : " + age);
    }

 第三方bean怎么进行依赖注入（直接在参数中写）

    @Bean
    public SAXReader ikun(DeptService deptService) {
        System.out.println(deptService);
        return new SAXReader();
    }

 Springboot项目中第三方的bean除了用bean注解是不是也可以定义继承类然后再交给 IOC ??

GPT4:是的，在Spring Boot项目中，除了使用@Bean注解创建第三方Bean，您还可以通过定义继承类并将其交给IoC容器来实现。以下是两种方法的详细说明：

1. 使用@Bean注解创建第三方Bean：

在Spring Boot项目的配置类（使用@Configuration注解的类）中，您可以使用@Bean注解来创建第三方Bean。例如：

java

Copy

@Configuration
public class AppConfig {

    @Bean
    public ThirdPartyClass thirdPartyClass() {
        return new ThirdPartyClass();
    }
}

在这个例子中，我们创建了一个名为thirdPartyClass的Bean，它是ThirdPartyClass类型的实例。这个Bean将在IoC容器中进行管理，可以在其他地方使用@Autowired注解进行注入。

1. 定义继承类并将其交给IoC容器：

您还可以通过创建一个继承自第三方类的类，并使用@Component、@Service、@Repository或@Controller等注解将其交给IoC容器。例如：

java

Copy

@Service
public class MyThirdPartyClass extends ThirdPartyClass {
}

在这个例子中，我们创建了一个名为MyThirdPartyClass的类，它继承自ThirdPartyClass。通过使用@Service注解，我们将MyThirdPartyClass交给了IoC容器进行管理。这样，您可以在其他地方使用@Autowired注解注入MyThirdPartyClass的实例。

总结一下，根据您的需求和项目结构，您可以选择使用@Bean注解创建第三方Bean，或者定义继承类并使用相应的注解将其交给IoC容器。两者都是可行的方法。

SpringBoot原理

 Springboot简化Spring的开发 注意是简化不是替代

 

起步依赖 

 自动配置

自动配置原理 

 没加注解时

package com.itheima;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan({"com.example","com.itheima"})//启动包扫描 本来的扫描会被覆盖掉，所以也要把本来会自动扫描的路径也写上
@SpringBootApplication
public class SpringbootWebConfig2Application {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootWebConfig2Application.class, args);
    }

}

还是不行

结果还是不行，算了c   反正这个方法不好

 

 

 idea2023不行就换到2022还是不行，但是2022第一种方法却能运行，服了

 唉，试着突然这个又行了。。。

 就这两个行，下面的就是不行，算了，快5点了，天都快亮了，明天还要上课，最™烦人还得是配置

今天下课了，吃完饭突然想起了，昨晚改了报名导致那两失败，因为在接口里面类名是写死的，用maven导入是不行的，但是在项目结构里面导入又行了，也不知道是为什么

开傍晚6点了，继续继续，加油干

 

 

 

 自动配置原理分析

 

 

 

 自定义starter

 

 

 很难理解的哇

 那就随便看一下代码吧

//仰晨study 创建时间2023/4/27 1:50 星期四
package com.aliyun.oss;

import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties(AliOSSProperties.class)
public class AliOSSAutoConfiguration {

    @Bean
    public AliOSSUtils aliOSSUtils(AliOSSProperties aliOSSProperties) {
        AliOSSUtils aliOSSUtils = new AliOSSUtils();
        aliOSSUtils.setAliOSSProperties(aliOSSProperties);
        return aliOSSUtils;
    }
}

 

//仰晨study 创建时间2023/4/23 16:48 星期日
package com.aliyun.oss;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "aliyun.oss")     //从文件里面注入属性值
public class AliOSSProperties {
    private String endpoint;
    private String accessKeyId;
    private String accessKeySecret;
    private String bucketName;


    public AliOSSProperties() {
    }

    public AliOSSProperties(String endpoint, String accessKeyId, String accessKeySecret, String bucketName) {
        this.endpoint = endpoint;
        this.accessKeyId = accessKeyId;
        this.accessKeySecret = accessKeySecret;
        this.bucketName = bucketName;
    }

    /**
     * 获取
     * @return endpoint
     */
    public String getEndpoint() {
        return endpoint;
    }

    /**
     * 设置
     * @param endpoint
     */
    public void setEndpoint(String endpoint) {
        this.endpoint = endpoint;
    }

    /**
     * 获取
     * @return accessKeyId
     */
    public String getAccessKeyId() {
        return accessKeyId;
    }

    /**
     * 设置
     * @param accessKeyId
     */
    public void setAccessKeyId(String accessKeyId) {
        this.accessKeyId = accessKeyId;
    }

    /**
     * 获取
     * @return accessKeySecret
     */
    public String getAccessKeySecret() {
        return accessKeySecret;
    }

    /**
     * 设置
     * @param accessKeySecret
     */
    public void setAccessKeySecret(String accessKeySecret) {
        this.accessKeySecret = accessKeySecret;
    }

    /**
     * 获取
     * @return bucketName
     */
    public String getBucketName() {
        return bucketName;
    }

    /**
     * 设置
     * @param bucketName
     */
    public void setBucketName(String bucketName) {
        this.bucketName = bucketName;
    }

    public String toString() {
        return "AliOSSProperties{endpoint = " + endpoint + ", accessKeyId = " + accessKeyId + ", accessKeySecret = " + accessKeySecret + ", bucketName = " + bucketName + "}";
    }
}

 

package com.aliyun.oss;

import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;
import java.util.UUID;

/**
 * 阿里云 OSS 工具类
 */
public class AliOSSUtils {

//    @Value("${aliyun.oss.endpoint}")
//    private String endpoint ;
//    @Value("${aliyun.oss.accessKeyId}")
//    private String accessKeyId ;
//    @Value("${aliyun.oss.accessKeySecret}")
//    private String accessKeySecret ;
//    @Value("${aliyun.oss.bucketName}")
//    private String bucketName ;

    private AliOSSProperties aliOSSProperties;

    public AliOSSProperties getAliOSSProperties() {
        return aliOSSProperties;
    }

    public void setAliOSSProperties(AliOSSProperties aliOSSProperties) {
        this.aliOSSProperties = aliOSSProperties;
    }

    /**
     * 实现上传图片到OSS
     */
    public String upload(MultipartFile file) throws IOException {
        // 配置文件注入的值要自己获取
        String endpoint = aliOSSProperties.getEndpoint();
        String accessKeyId = aliOSSProperties.getAccessKeyId();
        String bucketName = aliOSSProperties.getBucketName();
        String accessKeySecret = aliOSSProperties.getAccessKeySecret();


        // 获取上传的文件的输入流
        InputStream inputStream = file.getInputStream();

        // 避免文件覆盖
        String originalFilename = file.getOriginalFilename();
        String fileName = UUID.randomUUID().toString() + originalFilename.substring(originalFilename.lastIndexOf("."));

        //上传文件到 OSS
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        ossClient.putObject(bucketName, fileName, inputStream);

        //文件访问路径
        String url = endpoint.split("//")[0] + "//" + bucketName + "." + endpoint.split("//")[1] + "/" + fileName;
        // 关闭ossClient
        ossClient.shutdown();
        return url;// 把上传到oss的路径返回
    }

}

 

 专门测试写的starter写个模块

 

 web总结

 

 

 Maven高级

 

 分模块设计与开发

 

 

 

 创建2个Maven模块然后就包名写得和本来的一致就好，然后直接把本来的复制进去（报错的地方就导依赖），再把本来的删掉，再在本来的pom.xml里面引入进来。

注：因为这是演示原来的，正常情况下是先把这些公共模块写好，再写项目

 

继承与聚合 

 

 

 继承关系实现

1.创建maven模块 tlias-parent，该工程为父工程，设置打包方式pom(默认jar)。

 

 

 

 

Maven的3种打包方式

 版本锁定

 

 多了之后...

 

 聚合

 

 打包报错啦

 因为打包这个生命周期是在本地仓库里面去找这两个jar包，但是本地仓库根本就没有这两个jar包

 继续报错

因为父工程也要在本地仓库找，所以在父工程上也install就好了

然后再到项目打包

就成功啦 

 但是这样不是很繁琐吗?

所以聚合来啦...

 

 注意

 全部消失

 

 总结继承与聚合

 私服

 

<version>1.0-SNAPSHOT</version>  只要加了SNAPSHOT都会上传到SNAPSHOT仓库，不加或者加RELEASE就会发布到RELEASE仓库当中

 

 

 

 完美撒花✿

你以为结束了，但是这才是刚刚开始