在这里，我们将给大家分享关于【Java】【SpringBoot】Http请求后台服务报禁止跨域访问错误的知识，让您更了解springboot允许跨域请求的本质，同时也会涉及到如何更有效地9千字长文带你

在这里，我们将给大家分享关于【Java】【SpringBoot】Http请求后台服务报禁止跨域访问错误的知识，让您更了解springboot允许跨域请求的本质，同时也会涉及到如何更有效地9 千字长文带你了解 SpringBoot 启动过程 -- 史上最详细 SpringBoot 启动流程 - 图文并茂、Eclipse 下载 SpringBoot 插件、创建第一个 SpringBoot 项目、Java springboot B2B2C o2o 多用户商城 springcloud 架构 （十四）在 springboot 中用 redis 实现消息队列、Java springboot B2B2C o2o 多用户商城 springcloud 架构（九）springboot 整合 Redis的内容。

• 【Java】【SpringBoot】Http请求后台服务报禁止跨域访问错误（springboot允许跨域请求）
• 9 千字长文带你了解 SpringBoot 启动过程 -- 史上最详细 SpringBoot 启动流程 - 图文并茂
• Eclipse 下载 SpringBoot 插件、创建第一个 SpringBoot 项目
• Java springboot B2B2C o2o 多用户商城 springcloud 架构 （十四）在 springboot 中用 redis 实现消息队列
• Java springboot B2B2C o2o 多用户商城 springcloud 架构（九）springboot 整合 Redis

【Java】【SpringBoot】Http请求后台服务报禁止跨域访问错误（springboot允许跨域请求）

 错误信息：

解决方案：

 在SpringBoot的启动类中，增加一个统一的跨域过滤器：

    @Bean
    public CorsFilter corsFilter()
    {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", buildConfig());
        return new CorsFilter(source);
    }

    private CorsConfiguration buildConfig()
    {
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.addAllowedOrigin("*");
        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addAllowedMethod("*");
        return corsConfiguration;
    }

前端测试，问题解决：

9 千字长文带你了解 SpringBoot 启动过程 -- 史上最详细 SpringBoot 启动流程 - 图文并茂

来自面试官发自内审深处的灵魂拷问：“说一下 springboot 的启动流程”；
一脸懵逼的面试者：“它简化了 spring 的配置，主要是因为有自动装配的功能，并且可以直接启动，因为它内嵌了 tomcat 容器”；
面试官：“嗯， 没错，这是 它的一些概念，你还没回答我的问题，它是怎么启动的，启懂时都经过了哪些东西？”；
一脸懵逼的面试者：“额～～～不知道额・・・・，我用的很熟练，但是不知道它里面做了哪些事情！”；
面试官：“了解内部原理是为了帮助我们做扩展，同时也是验证了一个人的学习能力，如果你想让自己的职业道路更上一层楼，这些底层的东西你是必须要会的，行吧，你回去等消息吧！”
面试者：↓

SpringBoot 是什么

springboot 是依赖于 spring 的，比起 spring，除了拥有 spring 的全部功能以外，springboot 无需繁琐的 xml 配置，这取决于它自身强大的自动装配功能；并且自身已嵌入 Tomcat、Jetty 等 web 容器，集成了 springmvc，使得 springboot 可以直接运行，不需要额外的容器，提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等，

其实 spring 大家都知道，boot 是启动的意思。所以，spring boot 其实就是一个启动 spring 项目的一个工具而已，总而言之，springboot 是一个服务于框架的框架；也可以说 springboot 是一个工具，这个工具简化了 spring 的配置；
 

Spring Boot 的核心功能

1、 可独立运行的 Spring 项目：Spring Boot 可以以 jar 包的形式独立运行。

2、 内嵌的 Servlet 容器：Spring Boot 可以选择内嵌 Tomcat、Jetty 或者 Undertow，无须以 war 包形式部署项目。

3、 简化的 Maven 配置：Spring 提供推荐的基础 POM 文件来简化 Maven 配置。

4、 自动配置 Spring：Spring Boot 会根据项目依赖来自动配置 Spring 框架，极大地减少项目要使用的配置。

5、 提供生产就绪型功能：提供可以直接在生产环境中使用的功能，如性能指标、应用信息和应用健康检查。

6、 无代码生成和 xml 配置：Spring Boot 不生成代码。完全不需要任何 xml 配置即可实现 Spring 的所有配置。
 

SpringBoot 启动过程

springboot 的启动经过了一些一系列的处理，我们先看看整体过程的流程图

你别说，步骤还挺多，但是不要紧，为了帮助大家理解，接下来将上面的编号一个个地讲解，以通俗易懂的方式告诉大家，里面都做了什么事情，废话不多说，开整

1、运行 SpringApplication.run () 方法

可以肯定的是，所有的标准的 springboot 的应用程序都是从 run 方法开始的

package com.spring;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
 
@SpringBootApplication
public class App  {
 
    public static void main(String[] args) {
        // 启动springboot
        ConfigurableApplicationContext run = SpringApplication.run(App.class, args);
    }
 
}

进入 run 方法后，会 new 一个 SpringApplication 对象，创建这个对象的构造函数做了一些准备工作，编号第 2~5 步就是构造函数里面所做的事情

	/**
	 * Static helper that can be used to run a {@link SpringApplication} from the
	 * specified sources using default settings and user supplied arguments.
	 * @param primarySources the primary sources to load
	 * @param args the application arguments (usually passed from a Java main method)
	 * @return the running {@link ApplicationContext}
	 */
	public static ConfigurableApplicationContext run(Class<?>[] primarySources,
			String[] args) {
		return new SpringApplication(primarySources).run(args);
	}

另外在说明一下，springboot 启动有三种方式，其他的启动方式可参照我的另一个帖子： SpringBoot 的三种启动方式

2、确定应用程序类型

在 SpringApplication 的构造方法内，首先会通过 WebApplicationType.deduceFromClasspath ()； 方法判断当前应用程序的容器，默认使用的是 Servlet 容器，除了 servlet 之外，还有 NONE 和 REACTIVE （响应式编程）；

3、加载所有的初始化器

这里加载的初始化器是 springboot 自带初始化器，从从 META-INF/spring.factories 配置文件中加载的，那么这个文件在哪呢？自带有 2 个，分别在源码的 jar 包的 spring-boot-autoconfigure 项目 和 spring-boot 项目里面各有一个

spring.factories 文件里面，看到开头是 org.springframework.context.ApplicationContextInitializer 接口就是初始化器了 ，

当然，我们也可以自己实现一个自定义的初始化器：实现 ApplicationContextInitializer 接口既可

MyApplicationContextInitializer.java

package com.spring.application;
 
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
/**
 * 自定义的初始化器
 */
public class MyApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
        System.out.println("我是初始化的 MyApplicationContextInitializer...");
    }
}

在 resources 目录下添加 META-INF/spring.factories 配置文件，内容如下，将自定义的初始化器注册进去；

org.springframework.context.ApplicationContextInitializer=\
com.spring.application.MyApplicationContextInitializer

启动 springboot 后，就可以看到控制台打印的内容了，在这里我们可以很直观的看到它的执行顺序，是在打印 banner 的后面执行的；

4、加载所有的监听器

加载监听器也是从 META-INF/spring.factories 配置文件中加载的，与初始化不同的是，监听器加载的是实现了 ApplicationListener 接口的类

自定义监听器也跟初始化器一样，依葫芦画瓢就可以了，这里不在举例；

5、设置程序运行的主类

deduceMainApplicationClass (); 这个方法仅仅是找到 main 方法所在的类，为后面的扫包作准备，deduce 是推断的意思，所以准确地说，这个方法作用是推断出主方法所在的类；

6、开启计时器

程序运行到这里，就已经进入了 run 方法的主体了，第一步调用的 run 方法是静态方法，那个时候还没实例化 SpringApplication 对象，现在调用的 run 方法是非静态的，是需要实例化后才可以调用的，进来后首先会开启计时器，这个计时器有什么作用呢？顾名思义就使用来计时的嘛，计算 springboot 启动花了多长时间；关键代码如下：

// 实例化计时器
StopWatch stopWatch = new StopWatch(); 
// 开始计时
stopWatch.start();

run 方法代码段截图

7、将 java.awt.headless 设置为 true

这里将 java.awt.headless 设置为 true，表示运行在服务器端，在没有显示器器和鼠标键盘的模式下照样可以工作，模拟输入输出设备功能。

做了这样的操作后，SpringBoot 想干什么呢？其实是想设置该应用程序，即使没有检测到显示器，也允许其启动。对于服务器来说，是不需要显示器的，所以要这样设置.

方法主体如下：

	private void configureHeadlessProperty() {
		System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, System.getProperty(
				SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
	}

通过方法可以看到，setProperty () 方法里面又有个 getProperty ()；这不多此一举吗？其实 getProperty () 方法里面有 2 个参数， 第一个 key 值，第二个是默认值，意思是通过 key 值查找属性值，如果属性值为空，则返回默认值 true；保证了一定有值的情况；

8、获取并启用监听器

这一步 通过监听器来实现初始化的的基本操作，这一步做了 2 件事情

1. 创建所有 Spring 运行监听器并发布应用启动事件
2. 启用监听器
   

9、设置应用程序参数

将执行 run 方法时传入的参数封装成一个对象

仅仅是将参数封装成对象，没啥好说的，对象的构造函数如下

	public DefaultApplicationArguments(String[] args) {
		Assert.notNull(args, "Args must not be null");
		this.source = new Source(args);
		this.args = args;
	}

那么问题来了，这个参数是从哪来的呢？其实就是 main 方法里面执行静态 run 方法传入的参数，

10、准备环境变量

准备环境变量，包含系统属性和用户配置的属性，执行的代码块在 prepareEnvironment 方法内
打了断点之后可以看到，它将 maven 和系统的环境变量都加载进来了

11、忽略 bean 信息

这个方法 configureIgnoreBeanInfo () 这个方法是将 spring.beaninfo.ignore 的默认值值设为 true，意思是跳过 beanInfo 的搜索，其设置默认值的原理和第 7 步一样；

    private void configureIgnoreBeanInfo(ConfigurableEnvironment environment) {
		if (System.getProperty(
				CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME) == null) {
			Boolean ignore = environment.getProperty("spring.beaninfo.ignore",
					Boolean.class, Boolean.TRUE);
			System.setProperty(CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME,
					ignore.toString());
		}
	}

当然也可以在配置文件中添加以下配置来设为 false

spring.beaninfo.ignore=false

目前还不知道这个配置的具体作用，待作者查明后在补上

12、打印 banner 信息

显而易见，这个流程就是用来打印控制台那个很大的 spring 的 banner 的，就是下面这个东东

那他在哪里打印的呢？他在 SpringBootBanner.java 里面打印的，这个类实现了 Banner 接口，

而且 banner 信息是直接在代码里面写死的；

有些公司喜欢自定义 banner 信息，如果想要改成自己喜欢的图标该怎么办呢，其实很简单，只需要在 resources 目录下添加一个 banner.txt 的文件即可，txt 文件内容如下

                 _           _
                (_)         | |
 _   _  _____  ___ _ __   __| | ___  _ __   __ _
| | | |/ _ \ \/ / | ''_ \ / _` |/ _ \| ''_ \ / _` |
| |_| |  __/>  <| | | | | (_| | (_) | | | | (_| |
 \__, |\___/_/\_\_|_| |_|\__,_|\___/|_| |_|\__, |
  __/ |                                     __/ |
 |___/                                     |___/
:: yexindong::

一定要添加到 resources 目录下，别加错了

只需要加一个文件即可，其他什么都不用做，然后直接启动 springboot，就可以看到效果了

13、创建应用程序的上下文

实例化应用程序的上下文， 调用 createApplicationContext () 方法，这里就是用反射创建对象，没什么好说的；

14、实例化异常报告器

异常报告器是用来捕捉全局异常使用的，当 springboot 应用程序在发生异常时，异常报告器会将其捕捉并做相应处理，在 spring.factories 文件里配置了默认的异常报告器，

需要注意的是，这个异常报告器只会捕获启动过程抛出的异常，如果是在启动完成后，在用户请求时报错，异常报告器不会捕获请求中出现的异常，

了解原理了，接下来我们自己配置一个异常报告器来玩玩；

MyExceptionReporter.java 继承 SpringBootExceptionReporter 接口

package com.spring.application;
 
import org.springframework.boot.SpringBootExceptionReporter;
import org.springframework.context.ConfigurableApplicationContext;
 
public class MyExceptionReporter implements SpringBootExceptionReporter {
 
 
    private ConfigurableApplicationContext context;
    // 必须要有一个有参的构造函数，否则启动会报错
    MyExceptionReporter(ConfigurableApplicationContext context) {
        this.context = context;
    }
 
    @Override
    public boolean reportException(Throwable failure) {
        System.out.println("进入异常报告器");
        failure.printStackTrace();
        // 返回false会打印详细springboot错误信息，返回true则只打印异常信息 
        return false;
    }
}

在 spring.factories 文件中注册异常报告器

# Error Reporters 异常报告器
org.springframework.boot.SpringBootExceptionReporter=\
com.spring.application.MyExceptionReporter

接着我们在 application.yml 中 把端口号设置为一个很大的值，这样肯定会报错，

server:
  port: 80828888

启动后，控制台打印如下图

15、准备上下文环境

这里准备的上下文环境是为了下一步刷新做准备的，里面还做了一些额外的事情；

15.1、实例化单例的 beanName 生成器

在 postProcessApplicationContext (context); 方法里面。使用单例模式创建 了 BeanNameGenerator 对象，其实就是 beanName 生成器，用来生成 bean 对象的名称

15.2、执行初始化方法

初始化方法有哪些呢？还记得第 3 步里面加载的初始化器嘛？其实是执行第 3 步加载出来的所有初始化器，实现了 ApplicationContextInitializer 接口的类

15.3、将启动参数注册到容器中

这里将启动参数以单例的模式注册到容器中，是为了以后方便拿来使用，参数的 beanName 为 ：springApplicationArguments

16、刷新上下文

刷新上下文已经是 spring 的范畴了，自动装配和启动 tomcat 就是在这个方法里面完成的，还有其他的 spring 自带的机制在这里就不一一细说了，

17、刷新上下文后置处理

afterRefresh 方法是启动后的一些处理，留给用户扩展使用，目前这个方法里面是空的，

/**
	 * Called after the context has been refreshed.
	 * @param context the application context
	 * @param args the application arguments
	 */
	protected void afterRefresh(ConfigurableApplicationContext context,
			ApplicationArguments args) {
	}

18、结束计时器

到这一步，springboot 其实就已经完成了，计时器会打印启动 springboot 的时长

在控制台看到启动还是挺快的，不到 2 秒就启动完成了；

19、发布上下文准备就绪事件

告诉应用程序，我已经准备好了，可以开始工作了

20、执行自定义的 run 方法

这是一个扩展功能，callRunners (context, applicationArguments) 可以在启动完成后执行自定义的 run 方法；有 2 中方式可以实现：

1. 实现 ApplicationRunner 接口
2. 实现 CommandLineRunner 接口

接下来我们验证一把，为了方便代码可读性，我把这 2 种方式都放在同一个类里面

package com.spring.init;
 
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
 
/**
 * 自定义run方法的2种方式
 */
@Component
public class MyRunner implements ApplicationRunner, CommandLineRunner {
 
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println(" 我是自定义的run方法1，实现 ApplicationRunner 接口既可运行"        );
    }
 
    @Override
    public void run(String... args) throws Exception {
        System.out.println(" 我是自定义的run方法2，实现 CommandLineRunner 接口既可运行"        );
    }
}

启动 springboot 后就可以看到控制台打印的信息了

完

其实了解 springboot 启动原理对开发人员还是有好处的，至少你知道哪些东西是可以扩展的，以及怎么扩展，它的内部原理是怎么做的，我相信了解这些思路之后，让你自己写一个 springboot 出来也是可以的； 但是这里只是列出了启动过程，并不涉及到全部，源码是很负杂，记得一个大牛说过：“我们看源码的时候，只能通过联想或猜测作者是怎么想的，并且小心验证，就像我们小时候学古诗一样，也只能去猜测古人的想法，拿道德经来说，每个人读完后都有不同的看法，这就需要见仁见智了”；

Eclipse 下载 SpringBoot 插件、创建第一个 SpringBoot 项目

一、Eclipse 下载插件 SpringBoot 插件，我这里使用的是在线下载安装，给大家分享下。

1、help -> eclipse marketplace -> popular - 选择 spring tool suite(STS) 点击 Install 进行下载安装

2、接下来出现这个页面，操作如图

或者你也可以 help -> eclipse marketplace -> 输入 spring tool suite(STS) 点击 Go 进行搜索，出现spring tool suite(STS) 点击 Install 进行下载安装

3、接下来出现这个页面可能会有点慢，点击 Confirm

4、选择 accep，点击 Finish

接下来就开始下载了（下载时间可能有点长，所以动作要帅，网速要快）

测试是否下载好 SpringBoot 插件：

步骤：重启 eclipse 然后 File -> new -> other

出现如图所示文件列表即 SpringBoot 插件安装好了！

二、使用插件创建 SpringBoot 项目

跟之前的操作差不多：File -> new -> other -> spring -> Spring Starter Project -> next

这里点击 Next 即可下一步

注意：

如果你使用 Eclipse 的工作集来组织项目，那么也可以勾上 Add Project to Working Sets 这个复选框，选择一个工作集，这样就能把项目加入指定的工作集了。

Name：项目名称，Type：类型，Java Version：JDK版本，Packaging：打包方式，Language：语言 ，还有其他的这些都可以根据自己的需求修改。

next -> Web 栏目中 Web 打上勾表示创建一个 web项目（注意，不同版本 eclipse 显示的页面不同）-> Finish

最后，一个简单的 SpringBoot 项目已经创建好了，赶快去试试吧！

水平有限，若有问题请留言交流！

互相学习，共同进步：） 转载请注明出处谢谢！

Java springboot B2B2C o2o 多用户商城 springcloud 架构 （十四）在 springboot 中用 redis 实现消息队列

准备阶段

• 安装 redis, 可参考我的另一篇文章。
• java 1.8
• maven 3.0
• idea

环境依赖

创建一个新的 springboot 工程，在其 pom 文件，加入 spring-boot-starter-data-redis 依赖：

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

创建一个消息接收者

REcevier 类，它是一个普通的类，需要注入到 springboot 中。

public class Receiver {
    private static final Logger LOGGER = LoggerFactory.getLogger(Receiver.class);

    private CountDownLatch latch;

    @Autowired
    public Receiver(CountDownLatch latch) {
        this.latch = latch;
    }

    public void receiveMessage(String message) {
        LOGGER.info("Received <" + message + ">");
        latch.countDown();
    }
}

注入消息接收者

@Bean
    Receiver receiver(CountDownLatch latch) {
        return new Receiver(latch);
    }

    @Bean
    CountDownLatch latch() {
        return new CountDownLatch(1);
    }

    @Bean
    StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
        return new StringRedisTemplate(connectionFactory);
    }

注入消息监听容器

在 spring data redis 中，利用 redis 发送一条消息和接受一条消息，需要三样东西：

• 一个连接工厂
• 一个消息监听容器
• Redis template

上述 1、3 步已经完成，所以只需注入消息监听容器即可：

@Bean
    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                            MessageListenerAdapter listenerAdapter) {

        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(listenerAdapter, new PatternTopic("chat"));

        return container;
    }

    @Bean
    MessageListenerAdapter listenerAdapter(Receiver receiver) {
        return new MessageListenerAdapter(receiver, "receiveMessage");
    }

测试

在 springboot 入口的 main 方法：

public static void main(String[] args) throws Exception{
        ApplicationContext ctx =  SpringApplication.run(SpringbootRedisApplication.class, args);

        StringRedisTemplate template = ctx.getBean(StringRedisTemplate.class);
        CountDownLatch latch = ctx.getBean(CountDownLatch.class);

        LOGGER.info("Sending message...");
        template.convertAndSend("chat", "Hello from Redis!");

        latch.await();

        System.exit(0);
    }

Spring Cloud 大型企业分布式微服务云架构源码请加企鹅求求：一七九一七四三三八零

Java springboot B2B2C o2o 多用户商城 springcloud 架构（九）springboot 整合 Redis

引入依赖：

在 pom 文件中添加 redis 依赖：

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

配置数据源

spring.redis.host=localhost
spring.redis.port=6379
#spring.redis.password=
spring.redis.database=1
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
spring.redis.pool.max-idle=500
spring.redis.pool.min-idle=0
spring.redis.timeout=0

如果你的 redis 有密码，配置下即可。经过上述两步的操作，你可以访问 redis 数据了。

数据访问层 dao

通过 redisTemplate 来访问 redis.

@Repository
public class RedisDao {

    @Autowired
    private StringRedisTemplate template;

    public  void setKey(String key,String value){
        ValueOperations<String, String> ops = template.opsForValue();
        ops.set(key,value,1, TimeUnit.MINUTES);//1分钟过期
    }

    public String getValue(String key){
        ValueOperations<String, String> ops = this.template.opsForValue();
        return ops.get(key);
    }
}

单元测试

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootRedisApplicationTests {

    public static Logger logger= LoggerFactory.getLogger(SpringbootRedisApplicationTests.class);
    @Test
    public void contextLoads() {
    }

    @Autowired
    RedisDao redisDao;
    @Test
    public void testRedis(){
        redisDao.setKey("name","forezp");
        redisDao.setKey("age","11");
        logger.info(redisDao.getValue("name"));
        logger.info(redisDao.getValue("age"));
    }
}

启动单元测试，你发现控制台打印了：

forezp

11

单元测试通过；

Spring Cloud 大型企业分布式微服务云架构源码请加企鹅求求：一七九一七四三三八零

今天关于【Java】【SpringBoot】Http请求后台服务报禁止跨域访问错误和springboot允许跨域请求的介绍到此结束，谢谢您的阅读，有关9 千字长文带你了解 SpringBoot 启动过程 -- 史上最详细 SpringBoot 启动流程 - 图文并茂、Eclipse 下载 SpringBoot 插件、创建第一个 SpringBoot 项目、Java springboot B2B2C o2o 多用户商城 springcloud 架构 （十四）在 springboot 中用 redis 实现消息队列、Java springboot B2B2C o2o 多用户商城 springcloud 架构（九）springboot 整合 Redis等更多相关知识的信息可以在本站进行查询。