springboot入门

最新推荐文章于 2024-10-21 21:23:46 发布

暗影杀神

最新推荐文章于 2024-10-21 21:23:46 发布

阅读量123

点赞数

分类专栏： Spring Boot

本文链接：https://blog.youkuaiyun.com/weixin_43714592/article/details/104187558

版权

Spring Boot 专栏收录该内容

0 篇文章

订阅专栏

一、spring中java的bean配置（javaConfig）

Springboot原理基于它的

出现于spring3.x-4.x

二、spring的核心

1.环境搭建

创建maven项目，并导包

<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.3.12.RELEASE</version>
		</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>4.3.12.RELEASE</version>
</dependency>

2.spring测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext1.xml")
public class SpringTest {
    @Autowired
    private ApplicationContext applicationContext;
    //spring测试方式一：自己new容器
    @Test
    public void test1(){
        //通过xml初始化spring容器
        ApplicationContext context = new
                ClassPathXmlApplicationContext("applicationContext1.xml");
        String[] beanDefinitionNames = context.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
    }
    //spring测试方式二：测试创建容器
    @Test
    public void test2(){
        System.out.println(applicationContext);
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
    }
}

3.ioc-xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="myBean" class="java.util.Tripwire"></bean>
    <bean id="myBean1" class="cn.itcast._02iocxml.MyBean">
        <property name="name" value="ls"></property>
        <property name="iocBean" ref="iocBean"></property>
    </bean>
    <bean id="iocBean" class="cn.itcast._02iocxml.IocBean"></bean>
</beans>

public class IocBean {

}


public class MyBean {
    private String name;
    private IocBean iocBean;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public IocBean getIocBean() {
        return iocBean;
    }

    public void setIocBean(IocBean iocBean) {
        this.iocBean = iocBean;
    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext1.xml")
public class IocxmlTest {
    @Autowired
    private ApplicationContext applicationContext;
    @Test
    public void test1(){
        MyBean myBean = applicationContext.getBean(MyBean.class);
        System.out.println(myBean);
        IocBean iocBean = myBean.getIocBean();
        System.out.println(iocBean);
    }
}

3.ioc-注解

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
   <context:component-scan base-package="cn.itcast._03IocAnnotation"></context:component-scan>
</beans>

@Component
public class MyBean {
    private String name;
    @Autowired
    private IocBean iocBean;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public IocBean getIocBean() {
        return iocBean;
    }

    public void setIocBean(IocBean iocBean) {
        this.iocBean = iocBean;
    }
}

三、javaConfig

1.导包

<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.3.12.RELEASE</version>
		</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>4.3.12.RELEASE</version>
</dependency>

2.配置类测试

@Configuration//相当于原来的applicationContext.xml
public class IocConfig {
    @Bean("myBean")
    public MyBean get(){
        return new MyBean();
    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = IocConfig.class)
public class SpringTest {
    @Autowired
    private ApplicationContext applicationContext;
    //spring测试方式一
    @Test
    public void test1(){
        //通过xml初始化spring容器
        ApplicationContext context = new
                AnnotationConfigApplicationContext(IocConfig.class);
        String[] beanDefinitionNames = context.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
    }
    //spring测试方式二
    @Test
    public void test2(){
        System.out.println(applicationContext);
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
    }

}

3.ComponentScan扫描bean

@Configuration//相当于原来的applicationContext.xml
//方法一:扫描父包
//@ComponentScan("cn.itcast._05ComponentScan")
//方法二：配置多个包
//2.1 加多个@ComponentScan
//@ComponentScan("cn.itcast._05ComponentScan.Controllor")
//@ComponentScan("cn.itcast._05ComponentScan.Service")
//方法三： @ComponentScans
/*@ComponentScans(value = {
        @ComponentScan("cn.itcast._05ComponentScan.Controllor"),
        @ComponentScan("cn.itcast._05ComponentScan.Service")
})*/
//3 排除包里面某些类的bean,只包含某类注解的bean 其他的三个注解本身也是一个@Component
@ComponentScans(value = {
//        @ComponentScan(value = "cn.itcast._05ComponentScan",excludeFilters = {
//                //排除加了Component注解的bean
//                @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
//        })
        //只要改包下面的那些
        @ComponentScan(
                value = "cn.itcast._05ComponentScan",
                includeFilters = {
                        //排除加了Component注解的bean
                        @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Service.class})
                }
                ,useDefaultFilters = false //关闭默认全部扫描includeFilters才生效
        )
})
public class IocConfig {

}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = IocConfig.class)
public class MyIocTest {
    @Autowired
    private ApplicationContext applicationContext;
    @Test
    public void test1 () throws Exception{
        for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
    }
}

4.Bean详情

@Configuration
public class IocConfig {
    @Autowired
    private IocBean iocBean;
    //默认以方法名作为名称
    //@Bean("myBean") //配置名称
    //@Scope("singleton") //singleton单例(默认值) prototype多例
    //@Lazy //懒加载(默认)，用到的时候才去创建对象，并且只对单例模式有效
   /* public MyBean get(){
        // 方式1：创建对象直接设置值，没有在spring中
       //IocBean iocBean = new IocBean();
//        MyBean myBean = new MyBean();
//        myBean.setIocBean(iocBean);
        // 方式2：直接调用方法
//        MyBean myBean = new MyBean();
//        myBean.setIocBean(iocBean());

        //方式3：对注入的bean进行设置值
        MyBean myBean = new MyBean();
       myBean.setIocBean(iocBean);
        return myBean;
    }*/
    //方式4 通过构造函数进行注入 推荐使用
    @Bean
    public MyBean myBean(IocBean iocBean){
        return new MyBean(iocBean);
    }
    @Bean
    public IocBean iocBean(){
        return new IocBean();
    }
}

5.@Conditional-按照条件注册


@Configuration
@Conditional(value=Windows.class)
public class IocConfig {
    @Bean
    //可以加到方法上面，也可以加到类上面. 根据当前os.name的环境来判断
    @Conditional(value=Windows.class)
    public MyBean myWindows(){
       return new MyBean();
   }
    @Bean
    @Conditional(value=Linux.class)
    public MyBean myLinux(){
       return new MyBean();
   }
}

public class Windows implements Condition {
    //matches 匹配 如果是true表示注册，否则不注册
    // 1 conditionContext条件上下文
    // 2 AnnotatedTypeMetadata
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        //获取类加载器
        ClassLoader classLoader = conditionContext.getClassLoader();
        //获取spring的容器
        ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
        //获取bean定义注册器
        BeanDefinitionRegistry registry = conditionContext.getRegistry();
        //获取环境
        Environment environment = conditionContext.getEnvironment();
        String osName = environment.getProperty("os.name");
        System.out.println(osName);
        return osName.contains("Windows");
    }
}

6.@Import及使用FactoryBean注册组件

@Import({RedColor.class,BlackColor.class,MyImportSelector.class,MyImportBean.class})
public class IocConfig {
     @Bean
    public MyFactoryBean myFactoryBean(){
         return new MyFactoryBean();
     }

}

public class MyFactoryBean implements FactoryBean<My> {
    @Override
    public My getObject() throws Exception {
        return new My();
    }

    @Override
    public Class<?> getObjectType() {
        return My.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

public class MyImportBean implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        beanDefinitionRegistry.registerBeanDefinition("Yellow",new RootBeanDefinition(Yellow.class));
    }
}


public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{"cn.itcast._08Import.BlueColor"};
    }
}

四、Spring Boot简介

1.什么是Spring Boot？

springBoot是Spring项目中的一个子工程，与我们所熟知的Spring-framework 同属于spring的产品。

2.为什么要使用Spring Boot?

它解决了以下的传统问题：
2.1.配置负责繁多
2.2.混乱的依赖管理
在spirng中想集成对应组件时，需要导入N多的pom，并且还有考虑版本。
我们使用SpringBoot创建java应用，只需填写很少配置和依赖就能快速搭建，并使用java –jar 启动它，就能得到一个生产级别的web工程。非常方便

3.Spring Boot的特点

Spring Boot 主要目标是：

为所有 Spring 的开发者提供一个非常快速的、广泛接受的入门体验
开箱即用（启动器starter-其实就是SpringBoot提供的一个jar包），但通过自己设置参数（.properties），即可快速摆脱这种方式。
提供了一些大型项目中常见的非功能性特性，如内嵌服务器、安全、指标，健康检测、外部化配置等
绝对没有代码生成，也无需 XML 配置。

五、Spring Boot入门

1.创建maven并导包

  <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

注意：此时可能需要重启idea，重新加载jar包。

2.测试

新建启动类：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication//springboot的项目标识
public class App {
    public static void main(String[] args) {
        //启动一个应用
        SpringApplication.run(App.class);
    }
}

新建controller类：

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

//@RestController
@Controller
public class SpringBootController {
    @RequestMapping("/hello")
    @ResponseBody
    public String hello(){
        return "hello springboot";
    }
}

测试成功之后：
在这里插入图片描述

3.Jar包部署

打包项目的配置：

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

打包：
在这里插入图片描述
运行：
窗口运行：java -jar xxx.jar
后台运行: nohup java -jar XXX.jar 该命令只支持Linux系统