精华内容
下载资源
问答
  • 创建一个SpringBoot项目创建一个SpringBoot项目将SpringBoot项目打成jar包将SpringBoot项目打成war包设置pom.xml的自动提示 创建一个SpringBoot项目 创建一个空的项目 新建一个module 添加依赖 父项目pom....

    查看SpringBoot官方文档

    创建一个SpringBoot项目

    • 创建一个空的项目

    • 新建一个module
      在这里插入图片描述

    • 添加依赖

      • 父项目pom.xml

            <!--会把依赖都放到dependencyManagement-->
            <parent>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-parent</artifactId>
                <version>2.0.2.RELEASE</version>
            </parent>
        
      • 子项目pom,xml

        因为父项目是把依赖放到dependencyManagement的,子项目继承了版本号,所以子项目添加依赖的时候不需要提供版本号。

            <dependencies>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-web</artifactId>
                </dependency>
            </dependencies>
        

      dependencyManagement和dependency的区别

      • 如果父项目是把依赖放到dependency的,则子模块就会完全继承父模块的依赖。
      • 如果父项目是把依赖放到dependencyManagement的,这样子模块只会继承父模块的版本号,这样子目录添加依赖就不用提供版本号。
    • 创建App类 作为Springboot项目的入口
      @SpringBootApplication注解里有@ComponentScan,它会过滤当前类下的所有子目录,所以一般会把这个类放在最外层目录,这样子目录就都可以扫描到
      在这里插入图片描述

    • 创建测试类
      在这里插入图片描述

    • 可以在resources下创建一个Application.yml(可以用配置类代替)
      配置端口号等
      在这里插入图片描述

    将SpringBoot项目打成jar包

    要将SpringBoot项目打成jar包,需要在pom.xml加入如下依赖

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

    将SpringBoot项目打成war包

    要打成war包需要App类(加@SpringBootApplication的类)继承SpringBootServletInitializer,重写configure方法,返回super.configure(builder).sources(App.class);

    @SpringBootApplication
    public class App extends SpringBootServletInitializer {
    
        protected SpringApplicationBuilder configure(SpringApplicationBuilder builder){
            return super.configure(builder).sources(App.class);
        }
    
        public static void main(String[] args) {
            SpringApplication.run(App.class);
        }
    }
    
    

    设置pom.xml的自动提示

    更新本地Maven仓库,则pom.xml就会有提示
    在这里插入图片描述

    展开全文
  • 将idea,本地maven库等内容都配置好之后: 1:创建工程。File--New--Project--Maven--选择自己安装的jdk版本后next--项目名称、存放位置后next...3.创建启动类在main.java包中创建启动。启动代码格式如下: ...

    在将idea,本地maven库等内容都配置好之后:

    1:创建工程。File--New--Project--Maven--选择自己安装的jdk版本后next--项目名称、存放位置后next--finish。创建成功后的项目结构如下:

     

     

     

    2:导入依赖:在工程中找到pom文件,导入自己项目所需依赖。本文导入的是做web项目必须的"springboot-starter-web"依赖。

     

    3.创建启动类在main.java包中创建启动类。启动类代码格式如下:

    @SpringBootApplication//启动类注解,表明这是一个启动类
    public class StartApplication {
        public static void main(String[] args) {
            SpringApplication.run(StartApplication.class,args);
        }
    }

    4.编写Controller、serviece、dao等代码实现层,需要放在启动类的下级目录下,不能和启动类放在同一级目录:

     

    @RestController//注解,表明这是控制层。
    
    public class TestController {
    
    
    
        @GetMapping("/test/test")
    
        public String get(){
    
            return "test hello";
    
        }
    
    }

    5.

    五:有相关需求的话,在resources中编写application.yaml文件,用于修改相关配置。

    修改端口号:默认端口号为8080,当此端口被占用时,可以修改端口号

    Server:

    Port:xxxx

    可修改端口号为xxxx 

     

    六:启动项目

    在StartApplication文件中,单击右键--run

    七:项目启动成功后,通过浏览器进行验证。

    打开浏览器,输入localhost:8080/test/test,即可显示出test hello界面.

     

     

    展开全文
  • springboot 单例模式的两种写法 集成 service 因为是单例模式,所有需要spring上下文注入进来,才能获取到 @Component public class SpringContextUtils implements ApplicationContextAware { private static ...

    springboot 单例模式的两种写法

    • 集成 service
      因为是单例模式,所有需要spring上下文注入进来,才能获取到
    @Component
    public class SpringContextUtils implements ApplicationContextAware {
        private static ApplicationContext applicationContext;
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            SpringContextUtils.applicationContext = applicationContext;
        }
    
        /**
         * 获取 ApplicationContext
         *
         * @return
         */
        public static ApplicationContext getApplicationContext() {
            return applicationContext;
        }
    
        public static Object getBean(String name) {
            return applicationContext.getBean(name);
        }
    
        public static <T> T getBean(Class<T> clazz) {
            return applicationContext.getBean(clazz);
        }
    
        public static <T> T getBean(String name, Class<T> clazz) {
            return applicationContext.getBean(name, clazz);
        }
    
    }
    
    
    • 单列模式:饿汉式(一般最好使用饿汉式来操作)
    
    public class JdysEquipmentSinleton {
    
        private static  volatile JdysEquipmentSinleton INSYANCE;
    
        private int CODE;
    
        private IJdysEquipmentBillService jdysEquipmentBillServiceForNew;
    
        private JdysEquipmentSinleton(){
            jdysEquipmentBillServiceForNew = SpringContextUtils.getBean(IJdysEquipmentBillService.class);
        }
    
        public static JdysEquipmentSinleton getInstance(){
            if(null == INSYANCE){
                synchronized (JdysEquipmentSinleton.class){
                    if(null == INSYANCE){
                        INSYANCE = new JdysEquipmentSinleton();
                    }
                }
            }
            return INSYANCE;
        }
        public String getMaxEquipmentBillCode2(){
            if(0 != CODE){
                CODE += 1;
                return "D" + handelStrCode(CODE);
    
            }else {
                String maxEquipmentBillCode = DataUtil.isNotEmpty(jdysEquipmentBillServiceForNew.getMaxEquipmentBillCode()) ? jdysEquipmentBillServiceForNew.getMaxEquipmentBillCode() : "D00000";
                CODE += Integer.valueOf(maxEquipmentBillCode.substring(1,6));
                CODE += 1;
                return "D" + handelStrCode(CODE);
            }
        }
        public String handelStrCode(int code){
            int length = String.valueOf(code).length();
            int num = 0;
            if(length < 5){
                num = 5 - length;
            }
            String numCode = "";
            for (int i = 0; i < num; i++) {
                numCode += "0";
            }
            return numCode + code;
        }
    
    
    • 一般常用的懒汉式单例
     private LazyMan(){
           
            System.out.println(Thread.currentThread().getName() + "ok");
        }
    
    
        /**
         *  volatile 避免指令重排
         * */
        private volatile static LazyMan lazyMan;
    
        // 防止多线程出现问题,就使用了双重检测锁模式,懒汉式单列,     简称 DCL 懒汉式
        public static LazyMan getInstance(){
            if(null == lazyMan){
                synchronized (LazyMan.class){
                    if(null == lazyMan){
                        lazyMan = new LazyMan();  //在极端情况下不是一个原子性的操作
                        /**
                         * 1. 分配内存空间
                         * 2.执行构造方法,初始化对象
                         * 3.把这个对象指向这个空间
                         *
                         * 123 A
                         *
                         * 132 B
                         * */
                    }
                }
            }
            return lazyMan;  //当B线程进来的时候可以能 lazyMan 还没重拍好
        }
    
    • 使用单列模式和反射斗智
    package com.central.jdys.config;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    
    // 懒汉式单例(单列模式只会加载一次)
    public class LazyMan {
    
        private static boolean LazyFlag = false;
    
        private LazyMan(){
            // 保护反射机制来破坏
            synchronized (LazyMan.class){
                if(LazyFlag == false){
                    LazyFlag = true;
                }else {
                    throw new RuntimeException("不要用反射来破坏");
                }
            }
    
            System.out.println(Thread.currentThread().getName() + "ok");
        }
    
    
        /**
         *  volatile 避免指令重排
         * */
        private volatile static LazyMan lazyMan;
    
        // 防止多线程出现问题,就使用了双重检测锁模式,懒汉式单列,     简称 DCL 懒汉式
        public static LazyMan getInstance(){
            if(null == lazyMan){
                synchronized (LazyMan.class){
                    if(null == lazyMan){
                        lazyMan = new LazyMan();  //在极端情况下不是一个原子性的操作
                        /**
                         * 1. 分配内存空间
                         * 2.执行构造方法,初始化对象
                         * 3.把这个对象指向这个空间
                         *
                         * 123 A
                         *
                         * 132 B
                         * */
                    }
                }
            }
            return lazyMan;  //当B线程进来的时候可以能 lazyMan 还没重拍好
        }
    
    
        public static void main(String[] args) throws Exception {
    
            /**
             *  如果一个是通过单列加载,一个是通过反射new对象,那么就能在构造方法里面设置 synchronized 拦截住
             * */
    //
    //        LazyMan instance = LazyMan.getInstance();  //通过单列加载
    //        // 反射可以破坏单例
    //        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
    //        declaredConstructor.setAccessible(true);  //无视 私有关键字
    //        LazyMan lazyMan = declaredConstructor.newInstance();  //直接new一个对象
    
            /**
             *  当两个对象都是用反射加载的,那么就拦不住
             *
             *  解决,定义一个标志位LazyFlag,放在内部类,做判断
             *
             *  当然这种也是可以被破坏的
             * */
    
            /*** 拿到字段
             *  getDeclaredField 拿到字段
             *  setAccessible(true) 破坏私有属性
             * */
            Field lazyFlag = LazyMan.class.getDeclaredField("LazyFlag");
            lazyFlag.setAccessible(true);
    
    
            // 反射可以破坏单例
            Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
            declaredConstructor.setAccessible(true);  //无视 私有关键字
            LazyMan instance = declaredConstructor.newInstance();  //直接new一个对象
    
            /**
             *  通过反射new出对象后,在把 lazyFlag 的标志位 改为 false,就能重新new 对象
             * */
            lazyFlag.set(instance,false);
    
            LazyMan lazyMan = declaredConstructor.newInstance();  //直接new一个对象
    
            System.out.println(instance);
            System.out.println(lazyMan);
        }
    
        /**静态内部类实现*/
    
        public static class InnerClass{
    
        }
    }
    
    
    • 使用枚举
      – 枚举是没用办法使用反射来破解的,枚举没有无参构造,只有一个有参构造,一个是 String,一个是int类型,强行使用反射,jdk会直接抛出异常
    展开全文
  • spring 容器的创建对应 SpringApplication 中 run ...这里创建一个 web 容器,接下就进去 prepareContext 容器准备阶段:private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvir...

    spring 容器的创建对应 SpringApplication 中 run 中调用的 createApplicationContext 方法。这里创建了一个 web 容器,接下就进去 prepareContext 容器准备阶段:

    private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,

    SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {

    //为容器设置环境

    context.setEnvironment(environment);

    //这里的空实现留给开发者扩展,设置数据转换的ConversionService

    postProcessApplicationContext(context);

    //执行容器中的 Initializers 的 initialize 方法

    applyInitializers(context);

    listeners.contextPrepared(context);

    if (this.logStartupInfo) {

    logStartupInfo(context.getParent() == null);

    logStartupProfileInfo(context);

    }

    // Add boot specific singleton beans

    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();

    beanFactory.registerSingleton("springApplicationArguments", applicationArguments);

    if (printedBanner != null) {

    beanFactory.registerSingleton("springBootBanner", printedBanner);

    }

    if (beanFactory instanceof DefaultListableBeanFactory) {

    ((DefaultListableBeanFactory) beanFactory)

    .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);

    }

    if (this.lazyInitialization) {

    context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());

    }

    // Load the sources

    Set sources = getAllSources();

    Assert.notEmpty(sources, "Sources must not be empty");

    load(context, sources.toArray(new Object[0]));

    listeners.contextLoaded(context);

    }

    看一下这里的 load 方法,这里主要把我们的启动类作为 Bean 注册到了 Spring 的容器中。

    protected void load(ApplicationContext context, Object[] sources) {

    if (logger.isDebugEnabled()) {

    logger.debug("Loading source " + StringUtils.arrayToCommaDelimitedString(sources));

    }

    BeanDefinitionLoader loader = createBeanDefinitionLoader(getBeanDefinitionRegistry(context), sources);

    if (this.beanNameGenerator != null) {

    loader.setBeanNameGenerator(this.beanNameGenerator);

    }

    if (this.resourceLoader != null) {

    loader.setResourceLoader(this.resourceLoader);

    }

    if (this.environment != null) {

    loader.setEnvironment(this.environment);

    }

    loader.load();

    }

    /**

    * Load the sources into the reader.

    * @return the number of loaded beans

    */

    int load() {

    int count = 0;

    for (Object source : this.sources) {

    count += load(source);

    }

    return count;

    }

    private int load(Object source) {

    Assert.notNull(source, "Source must not be null");

    if (source instanceof Class>) {

    return load((Class>) source);

    }

    if (source instanceof Resource) {

    return load((Resource) source);

    }

    if (source instanceof Package) {

    return load((Package) source);

    }

    if (source instanceof CharSequence) {

    return load((CharSequence) source);

    }

    throw new IllegalArgumentException("Invalid source type " + source.getClass());

    }

    private int load(Class> source) {

    if (isGroovyPresent() && GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {

    // Any GroovyLoaders added in beans{} DSL can contribute beans here

    GroovyBeanDefinitionSource loader = BeanUtils.instantiateClass(source, GroovyBeanDefinitionSource.class);

    load(loader);

    }

    if (isEligible(source)) {

    this.annotatedReader.register(source);

    return 1;

    }

    return 0;

    }

    再来看下 contextLoaded 方法,这里将上下文设置到监听器中,同时也把监听器添加到上下文中。最后发布了一个 ApplicationPreparedEvent 事件。

    public void contextLoaded(ConfigurableApplicationContext context) {

    for (ApplicationListener> listener : this.application.getListeners()) {

    if (listener instanceof ApplicationContextAware) {

    ((ApplicationContextAware) listener).setApplicationContext(context);

    }

    context.addApplicationListener(listener);

    }

    this.initialMulticaster.multicastEvent(new ApplicationPreparedEvent(this.application, this.args, context));

    }

    到此这篇关于SpringBoot 创建容器的实现的文章就介绍到这了,更多相关SpringBoot 创建容器内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

    展开全文
  • 首先创建一个maven项目 打开idea,创建maven项目,并修改pom文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi=...
  • 创建一个SpringBoot项目

    热门讨论 2021-05-20 19:41:07
    什么是SpringBoot呢,就是一个javaweb的开发框架,和SpringMVC类似,对比其他javaweb框架的好处,官方说是简化开发,约定大于配置, you can "just run",能迅速的开发web应用,几行代码开发一个http接口。...
  • 1.打开idea工具>选择 Creat a New Projectimage.png2.选择界面上 Spring Initializr 点击 Next (https://start.spring.io表示是从官方网站获取到srpingboot初始化模板)...勾选你创建所需要的依赖 Web>Spring...
  • 使用springboot创建一个简单的java工程,连接mysql数据库,实现接口访问获取后端返回数据。 idea新建工程 1、idea中选择【File-New-Project】打开新建工程窗口,选择【Spring Initializr】,jdk版本选择1.8 2...
  • 不过这种方式一次只能创建一个对象;此外我们还可以使用@Configuration + @Bean的方式一次性创建多个对象。 而属性注入是指我们可以将配置文件中配置的信息注入到java文件中来使用。这样的使用场景实际开发中是...
  • 本文章作为SpringBoot的入门介绍,需要涉及到JDK、Maven、Idea等知识和开发环境的搭建。JDK的安装参考。Maven的安装,如果要配置Maven可以参考。Idea的安装参考。如果这些环境和工具都准备好了以后,将开启我们的...
  • 在springBoot中使用Mapper问题

    千次阅读 2021-02-18 17:56:07
    文章目录背景xml文件跟mapper分开方式一application.properties主程序Mapper方式二注意点xml文件跟mapper一个目录下application.propertiesmapper包下主程序感想 背景 版本如下: springboot=1.5.9 jdk=...
  • springboot 创建webservice服务接口 PS: 此处是 若依前后端分离式框架 基础上增加的webservice服务接口。 pom依赖: <!-- CXF webservice --> <dependency> <groupId>org.apache.cxf</...
  • 使用IDEA创建一个springboot项目 1.打开IDEA,点击 +Create New Project. 开始创建一个新项目。 2.左侧菜单找到并点击 Spring Initializr,点击next。 注意,这里idea默认使用https://start.spring.io提供的在线...
  • 1、在springboot中可以管理单个对象可以直接使用spring框架中注解形式创建。 @Component 通用的对象创建注解 --------> @Controller 用来创建控制器对象 --------> @Service 用来创建业务层对象 -------->...
  • springboot 开启一个异步线程

    千次阅读 2020-12-26 22:27:28
    使用步骤: Application上加上 @EnableAsync注解开启...异步方法不能与被调用的异步方法一个类中需要使用@Autowired或@Resource等注解自动注入,不能自己手动new对象 如果使用SpringBoot框架启动..
  • 你可能已经知道怎么为你的应用的一个类写单元测试了,所以,该篇博客会专注于使用spring的测试和springboot的功能来测试你的代码和spring之间的关系,你会应用上下文加载成功后开启测试,并继续使用MockMvc来测试web层...
  • SpringBoot创建项目详解

    2020-12-24 21:18:35
    Spring是一个开源框架,2003 年兴起的一个轻量级的Java 开发框架,作者:Rod Johnson 。 Spring是为了解决企业级应用开发的复杂性而创建的,简化开发。 为了降低Java开发的复杂性,Spring采用了以下4种关键策略: ...
  • springboot项目的基本结构和创建流程
  • 知其然知其所以然~ pom.xml:添加依赖 <dependency> <groupId>org.springframework.boot</groupId> ...spring-boot-starter-web-services<...创建:WebService接口 import java
  • 2.一个问题:SpringBoot的main函数中能够使用IOC容器中的Bean吗? 可以,但是是run程序之后,通过ApplicationContext获取的,不能是启动中使用注解注入的。 这要搞清楚SpringBoot的启动过程,连Tomcat都是run...
  • 1.原因:Cacheable默认使用aop代理方式,通过创建内部形式实现,而同一个类中调用无法通过代理,所以缓存不生效 2.解决方法:当前中注入该的bean对象,通过当前对象的代理对象实现缓存 public class ...
  • 如何快速创建你的第一个SpringBoot工程?如何运行我的工程?如何和前端用户简单交互?springboot创建项目很简单,第一种方式,直接访问官网,根据向导在线创建;第二种方法,你的 idea中使用模板创建工程。1. 第一...
  • SpringBoot创建定时任务的三种方式 一、基于Cron表达式创建   SpringBoot提供了@Schedule标签来创建定时任务,用此标签创建的定时任务为单线程,如果有多个定时任务,使用的是一个线程来执行的。具体使用如下: //...
  • 本文首发于微信公众号:"算法与编程之美",欢迎关注,及时了解更多此系列文章。前言很多小伙伴使用了IDEA之后,会发现用IDEA创建一个SpringBoot项目是一个很简单的事情。问题描述...
  • springboot线程池创建及使用

    千次阅读 2021-01-17 12:39:32
    springboot启动(Application.java)中配置线程池大小@Bean(name = "crawlExecutorPool")public ExecutorService crawlExecutorPool() {// 获取Java虚拟机的可用的处理器数,最佳线程数,处理器数*2。根据实际情况...
  • SpringBoot集成elasticsearch 文章目录SpringBoot集成elasticsearch前言一、准备工作二、使用步骤1....它提供了一个分布式多用户能力的全文搜索引擎,基于RESTful web接口。Elasticsearch是用Java语言开发的,并作为A
  • SpringBoot创建Zuul网关

    2021-01-04 15:25:58
    什么是Zuul Zuul 是 一个API网关,API网关可以提供一个单独且统一的API入口用于访问内部一个或多个API。它可以将一个一直的请求...创建一个SpringBoot应用 pom.xml添加依赖 <dependency> <groupId>org.
  • springboot创建流程: 1,创建一个springboot 2,设计分层,controller、service、dao、entity Controller定义一个方法,启动项目 会报错 url:(因为没有配置数据源)需要提前建好数据库 3、需要提前创建实体 4,...
  • 1、打开idea主界面选择 【Create New Project】 2、弹出的页面中我们选择左侧的【Spring Initializr】...由于我们需要构建一个Web项目通过访问Controller来验证项目是否成功搭建,所以这里需要添加Web包。 5、设置
  • # 线程池在springboot中的创建及使用## 第步 配置线程池### 创建线程池的Bean```@Configuration@EnableAsync@Slf4jpublic class ExecutorConfig {@Value("${async.executor.thread.core_pool_size}")private int ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 181,509
精华内容 72,603
关键字:

在springboot怎么创建一个类

spring 订阅