精华内容
参与话题
问答
  • SSM框架概念(什么是SSM框架

    千次阅读 多人点赞 2019-08-21 13:36:53
    全称为Spring+SpringMVC+MyBatis ,这个继SSH之后,目前比较主流的Java EE企业级框架,适用于搭建各种大型的企业级应用系统。 由Spring、MyBatis两个开源框架整合而成(SpringMVCSpring中的部分内容)。常...

            SSM框架

            全称为Spring+SpringMVC+MyBatis ,这个是继SSH之后,目前比较主流的Java EE企业级框架,适用于搭建各种大型的企业级应用系统。

            由Spring、MyBatis两个开源框架整合而成(SpringMVC是Spring中的部分内容)。常作为数据源较简单的web项目的框架。

            Spring

            Spring就像是整个项目中装配bean的大工厂,在配置文件中可以指定使用特定的参数去调用实体类的构造方法来实例化对象。也可以称之为项目中的粘合剂。
      Spring的核心思想是IoC(控制反转),即不再需要程序员去显式地'new'一个对象,而是让Spring框架帮你来完成这一切。

           简单来说,Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
      SpringMVC
      SpringMVC在项目中拦截用户请求,它的核心Servlet即DispatcherServlet承担中介或是前台这样的职责,将用户请求通过HandlerMapping去匹配Controller,Controller就是具体对应请求所执行的操作。SpringMVC相当于SSH框架中struts。

            Mybatis
      Mybatis是对jdbc的封装,它让数据库底层操作变的透明。mybatis的操作都是围绕一个sqlSessionFactory实例展开的。mybatis通过配置文件关联到各实体类的Mapper文件,Mapper文件中配置了每个类对数据库所需进行的sql语句映射。在每次与数据库交互时,通过sqlSessionFactory拿到一个sqlSession,再执行sql命令。

           页面发送请求给控制器,控制器调用业务层处理逻辑,逻辑层向持久层发送请求,持久层与数据库交互,后将结果返回给业务层,业务层将处理逻辑发送给控制器,控制器再调用视图展现数据。

    展开全文
  • 什么是框架

    千次阅读 2018-10-10 09:29:05
    在编程领域,软件框架是指一种抽象形式,它提供了一个具有通用功能的软件,这些功能可以由使用者编写代码来有选择的进行更改,从而提供服务于特定应用的软件。软件框架提供了一种标准的方式来构建并部署应用。 软件...

    在编程领域,软件框架是指一种抽象形式,它提供了一个具有通用功能的软件,这些功能可以由使用者编写代码来有选择的进行更改,从而提供服务于特定应用的软件。软件框架提供了一种标准的方式来构建并部署应用。

    软件框架是一种通用的、可复用的软件环境,它提供特定的功能,作为一个更大的软件平台的一部分,用以促进软件应用、产品和解决方案的开发工作。软件框架可能会包含支撑程序、编译器、代码、库、工具集以及 API,它把所有这些部件汇集在一起,以支持项目或系统的开发。

    框架和普通的库在特性上具有一些关键性的区别:

    *inversion of control_: In a framework, unlike in libraries or in standard user applications, the overall program’s flow of control is not dictated by the caller, but by the framework.*
    

    控制反转: 与库或普通的应用不同,在框架中,应用的宏观控制流程不是由调用者决定的,而是由框架本身。

    *extensibility_: A user can extend the framework – usually by selective overriding; or programmers can add specialized user code to provide specific functionality.*
    
    

    可扩展性: 用户可以扩展该框架 —— 通常是有选择的进行改写(Override)或者由程序员添加专门的用户代码来提供特定的功能。

    *non-modifiable framework code_: The framework code, in general, is not supposed to be modified, while accepting user-implemented extensions. In other words, users can extend the framework, but should not modify its code.*
    

    不可修改框架代码: 通常,框架代码都不打算让你修改,而是接受由用户自己实现的某些扩展。换句话说,用户可以扩展该框架,但是不应该修改它的代码。

    展开全文
  • Spring入门第一讲——Spring框架的快速入门

    万次阅读 多人点赞 2017-04-08 00:27:34
    Spring的概述什么是Spring据度娘所载: Spring是一个开源框架,Spring是于2003年兴起的一个轻量级的Java开发框架,由Rod Johnson创建。简单来说,Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。 ...

    Spring的概述

    什么是Spring?

    我们可以从度娘上看到这样有关Spring的介绍:
    在这里插入图片描述
    说得更加详细一点,Spring是一个开源框架,Spring是于2003年兴起的一个轻量级的Java开发框架,由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为J2EE应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益。Spring的核心是控制反转(IoC)和面向切面(AOP)。简单来说,Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。
    为什么说Spring是一个一站式的轻量级开源框架呢?EE开发可分成三层架构,针对JavaEE的三层结构,每一层Spring都提供了不同的解决技术。
    在这里插入图片描述
    从对Spring的简要介绍中,我们知道了Spring的核心有两部分:

    • IoC:即控制反转。举例来说,在之前的操作中,比方说有一个类,我们想要调用类里面的方法(不是静态方法),就要创建该类的对象,使用对象调用方法来实现。但对于Spring来说,Spring创建对象的过程,不是在代码里面实现的,而是交给Spring来进行配置实现的;
    • AOP:即面向切面编程。之前,讲Struts2框架的拦截器时,我们就已稍微讲了一下,在Spring后续的学习过程中,我们会着重来讲它,但是本文并不会过多阐述它。

    为什么学习Spring?

    在度娘上查看有关Spring的介绍时,我们可以找到如下一系列Spring的优点,这就是我们要学习Spring框架的原因。
    在这里插入图片描述

    Spring的快速入门

    Spring的版本

    需要说明的是,本系列入门Spring的教程使用的版本是spring-framework-4.2.4.RELEASE。

    IoC概述

    什么是IoC?

    IoC即Inversion of Control,反应过来就是控制反转。啥是控制反转啊?控制反转指的就是将对象的创建权反转给(交给)了Spring,其作用是实现了程序的解耦合。也可这样解释:获取对象的方式变了,对象创建的控制权不是"使用者",而是"框架"或者"容器"。用更通俗的话来说,IoC就是指对象的创建,并不是在代码中用new操作new出来的,而是通过Spring进行配置创建的。

    Spring的IoC的底层实现原理

    这里先给出结论:Spring的IoC的底层实现原理是工厂设计模式+反射+XML配置文件。 就拿持久层(也即dao层,data access object,数据访问对象)的开发来说,官方推荐做法是先创建一个接口,然后再创建接口对应的实现类。所以,这里,我会以dao层的开发为例来证明Spring的IoC的底层实现原理就是工厂设计模式+反射+XML配置文件。
    首先,创建一个Userdao接口。

    public interface UserDao {
    	public void add();
    }
    

    然后,再创建Userdao接口的一个实现类(UserDaoImpl.java)。

    public class UserDaoImpl implements UserDao {
        public void add() {
    	    balabala......
        }
    }
    

    接着,我们在service层中调用dao层,核心代码如下:

    // 接口 实例变量 = new 实现类
    UserDao dao = new UserDaoImpl();
    dao.add();
    

    这时我们便可发现一个缺点:service层和dao层耦合度太高了,即接口和实现类有耦合(它俩之间的联系过于紧密),一旦切换底层实现类,那么就需要修改源代码,这真的不是一个好的程序设计,好的程序设计应当满足OCP原则(也即开闭原则),即在尽量不修改程序源代码的基础上对程序进行扩展。说到这里,我就不得不稍微讲一下面向对象设计的七大原则了,它不必强记,重在理解。
    在这里插入图片描述
    出现的这个问题该如何解决呢?解决方法是使用工厂设计模式进行解耦合操作。所以,我们需要创建一个工厂类,在工厂类中提供一个方法,返回实现类的对象。

    public class BeanFactory {
        // 提供返回实现类对象的方法
        public static UserDao getUserDao() {
            return new UserDaoImpl();
        }
    }
    

    这样,在service层中调用dao层的核心代码就变为了下面的样子。

    UserDao dao = BeanFactory.getUserDao();
    dao.add();
    

    如若这样做,会发现又产生了一个缺点:现在接口和实现类之间是没有耦合了,但是service层和工厂类耦合了。如果真正想实现程序之间的解耦合,那么就需要使用到工厂设计模式+反射+XML配置文件了。所以,我们这里提供一个XML配置文件,并且该配置文件中有如下配置信息。

    <bean id="userDao" class="com.meimeixia.dao.impl.UserDaoImpl" />
    

    然后再来创建一个工厂类,在工厂类中提供一个返回实现类对象的方法,但并不是直接new实现类,而是使用SAX解析配置文件,根据标签bean中的id属性值得到对应的class属性值,使用反射创建实现类对象。

    public class BeanFactory {
        public static Object getBean(String id) {
            // 1.使用SAX解析得到配置文件内容
            // 直接根据id值userDao得到class属性值
            String classvalue = "class属性值";
            // 2.使用反射得到对象
            Class clazz = Class.forName(classvalue);
            UserDaoImpl userDaoImpl = (UserDaoImpl)lazz.newInstance();
            return userDaoImpl;
        }
    }
    

    以上就是Spring的IoC的底层实现原理。

    Spring的IoC入门

    下载Spring的开发包

    Spring的官网是https://spring.io/,Spring的开发包的下载地址是https://repo.spring.io/libs-release-local/org/springframework/spring/,上面说过,我下载的是spring-framework-4.2.4.RELEASE这个版本的Spring。解压缩之后,可发现Spring开发包的目录结构如下。
    在这里插入图片描述

    创建web项目,引入Spring的开发包

    首先创建一个动态web项目,例如spring_demo01,然后导入Spring框架相关依赖jar包,要导入哪些jar包呢?这是一个问题。
    在这里插入图片描述
    由于我们只是初次入门Spring,所以也只是使用到了Spring的基本功能,从上图红框框中的部分可知,我们需要使用到下面的这4个jar包。
    在这里插入图片描述
    除此之外,还要导入Spring支持的日志jar包,也就是下面两个jar包。
    在这里插入图片描述
    关于以上两个jar包,我稍微做一下解释,com.springsource.org.apache.commons.logging-1.1.1.jar它里面都是一些接口,有接口,那当然要有实现类了,恰好,com.springsource.org.apache.log4j-1.2.15.jar里面就是那些接口的实现类。使用Log4j,我们可以查看到当前运行程序中对象创建的过程,也可以看到更详细的信息,Log4j适合使用在程序调试中。
    导入完日志相关的jar包之后,我们还要导入日志记录文件,即在src目录下引入Log4j的配置文件(log4j.properties),该文件内容如下:

    ### direct log messages to stdout ###
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.Target=System.err
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
    
    ### direct messages to file mylog.log ###
    log4j.appender.file=org.apache.log4j.FileAppender
    log4j.appender.file.File=c\:mylog.log
    log4j.appender.file.layout=org.apache.log4j.PatternLayout
    log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
    
    ### set log levels - for more verbose logging change 'info' to 'debug' ###
    # error warn info debug trace
    log4j.rootLogger= info, stdout
    

    对以上日志记录文件,我会粗略讲解一下。
    在这里插入图片描述
    从上图可知,log4j.rootLogger就是用于设置日志的输出级别,那么日志的输出级别有几种呢?有如下5种。
    在这里插入图片描述

    创建接口和实现类

    首先,在src目录下创建一个com.meimeixia.spring.demo01包,并在该包下创建一个名为UserDao的接口。

    package com.meimeixia.spring.demo01;
    
    /**
     * 用户管理的dao层的接口
     * @author liayun
     *
     */
    public interface UserDao {
    
    	public void save();
    	
    }
    

    然后,在com.meimeixia.spring.demo01包下创建UserDao接口的一个实现类——UserDaoImpl.java。

    package com.meimeixia.spring.demo01;
    
    /**
     * 用户管理的dao层接口的实现类
     * @author liayun
     *
     */
    public class UserDaoImpl implements UserDao {
    
    	@Override
    	public void save() {
    		System.out.println("UserDaoImpl中的save方法执行了......");
    	}
    	
    }
    

    将实现类交给Spring管理

    首先,我们需要创建Spring的配置文件,Spring配置文件的名称和位置没有固定要求,一般建议把该文件放到src目录下面,名称可随便写,官方建议写成applicationContext.xml。然后我们还需要在配置文件中引入约束,Spring学习阶段的约束是schema约束。那么问题来了,这个约束又该怎么写呢?可参考docs\spring-framework-reference\html目录下的xsd-configuration.html文件,在其内容最后面找到如下内容。
    在这里插入图片描述
    将其复制黏贴到配置文件applicationContext.xml中,这样applicationContext.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">
            
    </beans>
    

    最后,咱还要将实现类交给Spring来管理,即在配置文件中配置对象的创建。

    <?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">
            
    	<!-- Spring入门的配置 -->
    	<bean id="userDao" class="com.meimeixia.spring.demo01.UserDaoImpl"></bean>
    	
    </beans>
    

    编写测试类

    我们要在Spring中写代码来实现获取applicationContext.xml文件中配置的对象,这段代码不要求大家重点掌握,只是用在测试中而已。这段代码主要用来解析Spring配置文件得到对象,但这个过程不需要我们写代码来实现了,Spring已经封装了一个对象来帮我们进行了这些操作,这个对象叫ApplicationContext,它就能实现这个功能。于是,我们需要在com.meimeixia.spring.demo01包下创建一个SpringDemo01的单元测试类。

    package com.meimeixia.spring.demo01;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.context.support.FileSystemXmlApplicationContext;
    
    /**
     * Spring的入门
     * @author liayun
     *
     */
    public class SpringDemo01 {
    	
    	/*
    	 * 传统方式的调用
    	 */
    	@Test
    	public void demo01() {
    		UserDao userDao = new UserDaoImpl();
    		userDao.save();
    	}
    	
    	/*
    	 * Spring的方式的调用
    	 */
    	@Test
    	public void demo02() {
    		//先要创建Spring的工厂
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");// classpath就是类路径,src目录下的文件最终要编译到类路径下
    		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    		userDao.save();
    	}
    
    }
    

    然后,运行以上demo02单元测试方法,Eclipse控制台就会打印如下内容。
    在这里插入图片描述

    Spring IoC和DI的区别

    IoC上面我已经讲过了,它指的就是将对象的创建权反转给(交给)了Spring。那DI又是什么鬼呢?DI,即Dependency Injection,翻译过来就是依赖注入,它指的就是Spring在管理某个类的时候会将该类依赖的属性注入(设置)进来,也就是说在创建对象的过程中,向类里面的属性中设置值。注意:依赖注入不能单独存在,须在控制反转基础之上完成,用更通俗点的话来说,就是注入类里面的属性值,不能直接注入,须创建类的对象再完成注入。
    你还记得在面向对象设计的时候,类和类之间有几种关系吗?有3种,它们分别是:

    • 依赖,由于下图中B类的方法用到了A类,所以此时就可以说B类依赖于A类;
      在这里插入图片描述
    • 继承(is a),这种关系我们应该是见的要吐了;
      在这里插入图片描述
    • 聚合(has a),它有松散和紧密之分。例如,球队得有一个守门员,即使这个球队没有了这个守门员,它也还是一个球队,所以它是松散的;人得有一个脑袋,此时它就是紧密的。

    说了这么多,咱就通过一个案例来看看DI在程序的体现。现在,我们想要给UserDaoImpl这个实现类里面的某一个属性(例如String类型的name)设置值,该咋怎呢?首先,将UserDaoImpl这个实现类修改成下面这个样子。

    package com.meimeixia.spring.demo01;
    
    /**
     * 用户管理的dao层接口的实现类
     * @author liayun
     *
     */
    public class UserDaoImpl implements UserDao {
    	
    	private String name;
    	
    	//提供set方法
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public void save() {
    		System.out.println("UserDaoImpl中的save方法执行了......" + name);
    	}
    	
    }
    

    如果使用传统的方式来为UserDaoImpl实现类的name属性设置值,那么SpringDemo01单元测试类中的demo01方法就应该写成下面这个样子。

    package com.meimeixia.spring.demo01;
    
    import org.junit.Test;
    
    /**
     * Spring的入门
     * @author liayun
     *
     */
    public class SpringDemo01 {
    	
    	/*
    	 * 传统方式的调用
    	 */
    	@Test
    	public void demo01() {
    		/*
    		 * 我想给这个类里面的某一个属性设置值,挺麻烦的!
    		 * 
    		 * 1. 不能面向接口编程了
    		 * 2. 你还得手动调用set方法,也得去改变程序的源代码
    		 */
    		UserDaoImpl userDao = new UserDaoImpl();
    		userDao.setName("李二");
    		userDao.save();
    	}
    
    }
    

    这样写,就有两个缺点,一是不能面向接口编程了,二是咱还得手动调用对象的set方法,这必然就涉及到要改变程序的源代码了,这是我们不能接受的!
    如果使用了依赖注入,即在applicationContext.xml文件中为配置好的UserDaoImpl实现类的name属性注入一个值,那么情况就完全不同了,以上两个缺点也就不复存在了。

    <?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">
            
    	<!-- Spring入门的配置 -->
    	<bean id="userDao" class="com.meimeixia.spring.demo01.UserDaoImpl">
    		<!-- DI:依赖注入 -->
    		<property name="name" value="李二" />
    	</bean>
    	
    </beans>
    

    此时,SpringDemo01单元测试类中的demo02方法依然不变,如下。

    package com.meimeixia.spring.demo01;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.context.support.FileSystemXmlApplicationContext;
    
    /**
     * Spring的入门
     * @author liayun
     *
     */
    public class SpringDemo01 {
    	
    	/*
    	 * 传统方式的调用
    	 */
    	@Test
    	public void demo01() {		
    		/*
    		 * 我想给这个类里面的某一个属性设置值,挺麻烦的!
    		 * 
    		 * 1. 不能面向接口编程了
    		 * 2. 你还得手动调用set方法,也得去改变程序的源代码
    		 */
    		UserDaoImpl userDao = new UserDaoImpl();
    		userDao.setName("李二");
    		userDao.save();
    	}
    	
    	/*
    	 * Spring的方式的调用
    	 */
    	@Test
    	public void demo02() {
    		//先要创建Spring的工厂
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    		userDao.save();
    	}
    
    }
    

    运行以上demo02单元测试方法,Eclipse控制台就会打印出如下内容。
    在这里插入图片描述

    Spring的工厂类

    Spring工厂类的结构图

    在这里插入图片描述
    从上图可以看出ApplicationContext(接口)继承自BeanFactory(接口)。

    BeanFactory:老版本的工厂类

    BeanFactory是老版本的工厂类,稍微了解一下就好,这个类在实际开发中我们并不需要用到。需要说明的一点是,它只有在调用getBean方法的时候,才会生成Spring所管理的类的实例。

    ApplicationContext:新版本的工厂类

    ApplicationContext是新版本的工厂类,它在加载配置文件的时候,就会将Spring所管理的类都实例化。ApplicationContext这个接口有两个实现类,如下图所示。
    在这里插入图片描述
    ClassPathXmlApplicationContext这个实现类前面用过了,下面咱就来用一下FileSystemXmlApplicationContext这个实现类。首先,拷贝一份applicationContext.xml文件到C盘下,其内容做一点点修改。
    在这里插入图片描述
    然后,在SpringDemo01单元测试类中编写如下一个demo03方法。

    package com.meimeixia.spring.demo01;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.context.support.FileSystemXmlApplicationContext;
    
    /**
     * Spring的入门
     * @author liayun
     *
     */
    public class SpringDemo01 {
    	
    	/*
    	 * 传统方式的调用
    	 */
    	@Test
    	public void demo01() {	
    		/*
    		 * 我想给这个类里面的某一个属性设置值,挺麻烦的!
    		 * 
    		 * 1. 不能面向接口编程了
    		 * 2. 你还得手动调用set方法,也得去改变程序的源代码
    		 */
    		UserDaoImpl userDao = new UserDaoImpl();
    		userDao.setName("李二");
    		userDao.save();
    	}
    	
    	/*
    	 * Spring的方式的调用
    	 */
    	@Test
    	public void demo02() {
    		//先要创建Spring的工厂
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    		userDao.save();
    	}
    	
    	/*
    	 * 加载磁盘上的配置文件
    	 */
    	@Test
    	public void demo03() {
    		//先要创建Spring的工厂
    		ApplicationContext applicationContext = new FileSystemXmlApplicationContext("C:\\applicationContext.xml");
    		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    		userDao.save();
    	}
    
    }
    

    最后,运行以上demo03单元测试方法,Eclipse控制台就会打印出如下内容。
    在这里插入图片描述

    展开全文
  • 初识Spring Boot框架

    万次阅读 多人点赞 2016-12-19 20:42:04
    前面的铺垫文章已经连着写了六篇了,主要介绍了Spring和SpringMVC框架,小伙伴们在学习的过程中大概也发现了这两个框架需要我们手动配置的地方非常多,不过做JavaEE开发的小伙伴们肯定也听说过“约定大于配置”...

    关注公众号【江南一点雨】,专注于 Spring Boot+微服务以及前后端分离等全栈技术,定期视频教程分享,关注后回复 Java ,领取松哥为你精心准备的 Java 干货!

    前面的铺垫文章已经连着写了六篇了,主要是介绍了Spring和SpringMVC框架,小伙伴们在学习的过程中大概也发现了这两个框架需要我们手动配置的地方非常多,不过做JavaEE开发的小伙伴们肯定也听说过“约定大于配置”这样一句话,就是说系统,类库,框架应该假定合理的默认值,而非要求提供不必要的配置,可是使用Spring或者SpringMVC的话依然有许多这样的东西需要我们进行配置,这样不仅徒增工作量而且在跨平台部署时容易出问题。OK,由于这些已经存在的问题,Spring Boot应运而生,使用Spring Boot可以让我们快速创建一个基于Spring的项目,而让这个Spring项目跑起来我们只需要很少的配置就可以了。Spring Boot主要有如下核心功能:

    1.独立运行的Spring项目

    Spring Boot可以以jar包的形式来运行,运行一个Spring Boot项目我们只需要通过java -jar xx.jar类运行。非常方便。

    2.内嵌Servlet容器

    Spring Boot可以内嵌Tomcat,这样我们无需以war包的形式部署项目。

    3.提供starter简化Maven配置

    使用Spring或者SpringMVC我们需要添加大量的依赖,而这些依赖很多都是固定的,这里Spring Boot 通过starter能够帮助我们简化Maven配置。

    4.自动配置Spring
    5.准生产的应用监控
    6.无代码生成和xml配置

    OK,关于SpringBoot更详细的优缺点小伙伴们也可以自行搜索,我这里不再罗列,我们还是来看看代码。
    #项目创建
    初次接触,我们先来看看如何创建一个Spring Boot项目,这里以IntelliJ IDEA为例,其他的IDE工具小伙伴们自行搜索创建方式:

    首先创建一个项目,创建时选择Spring Initializr,然后Next,如下图:

    这里写图片描述

    填写项目信息,如下图:

    这里写图片描述

    填写项目使用到的技术,上面的Spring Boot版本建议选择最新的稳定版,下面勾选上Web就可以了,如下图:

    这里写图片描述

    最后一步,填写工程名字点击finish:

    这里写图片描述
    OK,第一次创建时系统会去下载需要的依赖等,耗时稍长,以后每次都会很快创建好。
    OK,项目创建成功之后接下来我们来看看这个东西要怎么样去运行。首先我们看到在项目创建成功之后,在项目的根目录下会有一个artifactId+Application命名规则的入口类,如下图:
    这里写图片描述,就是这个Test19SpringBoot2Application类,这是我们整个项目的入口类,这个类有一个@SpringBootApplication注解,这是整个Spring Boot的核心注解,它的目的就是开启Spring Boot的自动配置。OK,那么我在这个类上再添加一个@RestController注解,使之变为一个Controller,然后里边提供一个地址转换方法,如下:

    @RestController
    @SpringBootApplication
    public class Test19SpringBoot2Application {
    
    	public static void main(String[] args) {
    		SpringApplication.run(Test19SpringBoot2Application.class, args);
    	}
    
    	@RequestMapping(value = "/",produces = "text/plain;charset=UTF-8")
    	String index(){
    		return "Hello Spring Boot!";
    	}
    }
    

    然后点击项目启动按钮运行,在IntelliJ中就是这个按钮:
    这里写图片描述
    启动成功之后我们就可以直接在浏览器中访问了,如下:
    这里写图片描述
    OK,至此,我们一个简单的Spring Boot工程已经创建出来了,并且成功的从浏览器中访问到了,但是为什么它最终会跑起来呢?想必小伙伴们还有许多疑问,我们来分析下。
    #入口类和@SpringBootApplication注解

    上文说过,我们新建一个Project系统都会帮我们创建一个名为artifactId+Application的入口类,这个类中有一个main方法,这个main方法就是一个标准的Java应用程序的入口方法。而这里的@SpringBootApplication则是一个组合注解,我们可以看看它的源码:

    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan(
        excludeFilters = {@Filter(
        type = FilterType.CUSTOM,
        classes = {TypeExcludeFilter.class}
    )}
    )
    public @interface SpringBootApplication {
    
    }
    

    我们可以看到它组合了@SpringBootConfiguration、@EnableAutoConfiguration以及@ComponentScan,我们在开发的过程中如果不使用@SpringBootApplication,则可以组合使用这三个注解。这三个注解中,@SpringBootConfiguration实际上就是我们前面几篇博客提到的@Configuration注解,表明这个类是一个配置类,@EnableAutoConfiguration则表示让Spring Boot根据类路径中的jar包依赖为当前项目进行自动配置,最后一个@ComponentScan的作用我也不赘述了,唯一要注意的是如果我们使用了@SpringBootApplication注解的话,系统会去入口类的同级包以及下级包中去扫描实体类,因此我们建议入口类的位置在groupId+arctifactID组合的包名下。

    #关闭特定的自动配置
    在上面一小节中我们看到@ComponentScan注解是有一个过滤器的,如果我们只想要@SpringBootApplication去扫描特定的类而不是全部类,那么就可以关闭自动配置,如下:

    @SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
    

    #定制Banner
    ##修改Banner
    我们在启动Spring Boot项目的时候,在控制台会默认输出一个启动图案,如下:
    这里写图片描述
    当然,这个图案如果你需要的话是可以自己修改的,修改方式很简单:

    1.在src/main/resources下新建一个banner.txt文档
    2.通过http://patorjk.com/software/taag网站生成需要的字符,将字符拷贝到步骤1所创建的txt文档中,比如我这里为Hello Sang!生成字符,如下:

    这里写图片描述
    点击左下角的选择和拷贝按钮,将这个字符拷贝到txt文档中,然后再启动项目,这个时候控制台输出的文本就会自动改变,如下:
    这里写图片描述
    ##关闭Banner
    可以修改当然也可以关闭,关闭Banner需要我们稍微修改一下main方法中的代码,如下:

    public static void main(String[] args) {
    		SpringApplicationBuilder builder = new SpringApplicationBuilder(Test19SpringBoot2Application.class);
    		//修改Banner的模式为OFF
    		builder.bannerMode(Banner.Mode.OFF).run(args);
    	}
    

    OK,如此修改之后当我们再次启动Project的时候就看不到Banner了。

    #Spring Boot的配置文件
    Spring Boot使用一个全局的配置文件application.properties或者application.yml,配置文件放在src/main/resources目录下。properties是我们常见的一种配置文件,Spring Boot不仅支持properties这种类型的配置文件,也支持yaml语言的配置文件,我这里以properties类型的配置文件为例来看几个案例。

    1.修改Tomcat默认端口和默认访问路径

    Tomcat默认端口是8080,我将之改为8081,默认访问路径是http://localhost:8080,我将之改为http://localhost:8081/helloboot,我们来看看这两个需求要怎么样通过简单的配置来实现。
    很简单,在application.properties文件中添加如下代码:

    server.context-path=/helloboot
    server.port=8081
    

    然后再启动Project,在浏览器中就得这样来访问了:
    这里写图片描述

    常规属性配置

    在前面的博客( Spring常用配置 )中我们介绍了如何在使用Spring容器框架下注入properties文件里的值。如果我们使用了Spring Boot,这项工作将会变得更加简单,我们只需要在application.properties中定义属性,然后在代码中直接使用@Value注入即可。
    如下:

    book.author=罗贯中
    book.name=三国演义
    book.pinyin=sanguoyanyi
    

    我这里专门设置了中文,因为中文不做特殊处理会乱码,处理方式为继续在application.properties中添加如下代码:

    server.tomcat.uri-encoding=UTF-8
    spring.http.encoding.charset=UTF-8
    spring.http.encoding.enabled=true
    spring.http.encoding.force=true
    spring.messages.encoding=UTF-8
    

    然后 在IntelliJ IDEA中依次点击File -> Settings -> Editor -> File Encodings
    将Properties Files (*.properties)下的Default encoding for properties files设置为UTF-8,将Transparent native-to-ascii conversion前的勾选上。(参考【Springboot 之 解决IDEA读取properties配置文件的中文乱码问题】【Springboot 之 解决IDEA读取properties配置文件的中文乱码问题】)。
    然后在变量中通过@Value直接注入就行了,如下:

    	@Value(value = "${book.author}")
    	private String bookAuthor;
    	@Value("${book.name}")
    	private String bookName;
    	@Value("${book.pinyin}")
    	private String bookPinYin;
    

    修改index方法,使之返回这些值:

    @RequestMapping(value = "/",produces = "text/plain;charset=UTF-8")
    	String index(){
    		return "Hello Spring Boot! The BookName is "+bookName+";and Book Author is "+bookAuthor+";and Book PinYin is "+bookPinYin;
    	}
    

    然后在浏览器中访问,结果如下:
    这里写图片描述

    很简单吧。

    类型安全的配置

    刚刚说的这种方式我们在实际项目中使用的时候工作量略大,因为每个项目要注入的变量的值太多了,这种时候我们可以使用基于类型安全的配置方式,就是将properties属性和一个Bean关联在一起,这样使用起来会更加方便。我么来看看这种方式怎么实现。

    1.在src/main/resources文件夹下创建文件book.properties

    文件内容如下:

    book.name=红楼梦
    book.author=曹雪芹
    book.price=28
    

    2.创建Book Bean,并注入properties文件中的值

    代码如下:

    @Component
    @ConfigurationProperties(prefix = "book",locations = "classpath:book.properties")
    public class BookBean {
        private String name;
        private String author;
        private String price;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAuthor() {
            return author;
        }
    
        public void setAuthor(String author) {
            this.author = author;
        }
    
        public String getPrice() {
            return price;
        }
    
        public void setPrice(String price) {
            this.price = price;
        }
    }
    

    prefix是指前缀,location指定要注入文件的位置。

    3.添加路径映射

    在Controller中添加如下代码注入Bean:

    @Autowired
    	private BookBean bookBean;
    

    添加路径映射:

    @RequestMapping("/book")
    	public String book() {
    		return "Hello Spring Boot! The BookName is "+bookBean.getName()+";and Book Author is "+bookBean.getAuthor()+";and Book price is "+bookBean.getPrice();
    	}
    

    运行效果如下:

    #日志配置
    默认情况下Spring Boot使用Logback作为日志框架,也就是我们前面几篇博客中用到的打印日志方式,当然如果有需要我们可以手动配置日志级别以及日志输出位置,相比于我们在Spring容器中写的日志输出代码,这里的配置简直就是小儿科了,只需要在application.properties中添加如下代码:

    logging.file=/home/sang/workspace/log.log
    logging.level.org.springframework.web=debug
    

    上面表示配置日志输出位置,下面配置日志级别。

    #Profile配置问题
    Spring常用配置 这篇文章中,我们已经介绍了Profile的作用,已经如何在Spring框架下使用Profile,但是当时小伙伴们看到了还是稍微有点麻烦,在Spring Boot 中系统提供了更为简洁的方式。全局Profile配置我们使用application-{profile}.properties来定义,然后在application.properties中通过spring.profiles.active来指定使用哪个Profile。OK,那么接下来我们来看一个简单的案例。

    1.在src/main/resources文件夹下定义不同环境下的Profile配置文件,文件名分别为application-prod.properties和application-dev.properties,这两个前者表示生产环境下的配置,后者表示开发环境下的配置,如下:

    这里写图片描述

    application-prod.properties:

    server.port=8081
    

    application-dev.properties:

    server.port=8080
    

    然后在application.properties中进行简单配置,如下:

    spring.profiles.active=dev
    

    这个表示使用开发环境下的配置。然后运行项目,我们得通过8080端口才可以访问:
    这里写图片描述
    如果想换为生产环境,只需要把spring.profiles.active=dev改为spring.profiles.active=prod即可,当然访问端口这是也变为8081了,如下:
    这里写图片描述

    本案例下载地址:
    本项目GitHub地址

    以上。

    参考资料:
    《JavaEE开发的颠覆者 Spring Boot实战》第五章、第六章

    展开全文
  • 1.什么是框架? 其实框架,就是别人写好了包装起来的一套工具,把你原先必须要写的,必须要做的一些复杂的东西都写好了放在那里,你只要调用他的方法,就可以实现一些本来要费好大劲的功能。形象一点说吧,假如你盖...
  • Qt图形视图框架详解

    千人学习 2016-12-07 16:50:42
    Qt图形视图框架详解视频教程,介绍Qt中的Graphics View Framework,涉及View、Scene、Item的关系,如何自定义QGraphicsItem、处理Item之间的关联、如何布局及定义自己的布局Item、如何变幻Item、如何应用动画、如何...
  • 分清什么是库,什么是框架

    万次阅读 2019-09-06 09:57:05
    什么是框架?俩者有什么关联与区别? 库的概念: 库就像是一个工具箱,我们可以使用这个工具箱去完成一些我们想要的功能,甚至我们可以去改造一些东西,比如说jQuery,库的使用几乎是没什么约束的。 框架的概念: ...
  • 毕业设计本科教育的最后一个环节,整个过程包括课题拟定与审核、师生双选、开题报告、文档审核、中期检查、毕业答辩等多个环节,一项系统而复杂的工作。开发一个适合本校的毕业设计管理系统,不仅能够极大地减少...
  • 什么是框架

    万次阅读 多人点赞 2007-11-20 18:56:00
    导读: 框架(Framework)整个或部分系统的可重用设计,表现为一组抽象构件及构件实例间交互的方法;另一种定义认为,框架是可被应用开发者定制的应用骨架。前者从应用方面而后者从目的方面给出的定义。 可以说...
  • 常见python爬虫框架

    万次阅读 2017-07-21 16:26:34
    一、python爬虫框架  一些爬虫项目的半成品 二、常见python爬虫框架  (1)Scrapy:很强大的爬虫框架,可以满足简单的页面爬取(比如可以明确获知url pattern的情况)。用这个框架可以轻松爬下来如亚马逊商品...
  • Java并发框架——什么是AQS框架

    千次阅读 2014-11-09 23:04:57
    什么是AQS框架 1995年sun公司发布了第一个java语言版本,可以说从jdk1.1到jdk1.4期间java的使用主要是在移动应用和中小型企业应用中,在此类领域中基本不用设计大型并发场景,当然也没有大型互联网公司使用java,...
  • 什么是 RPC 框架

    万次阅读 多人点赞 2018-03-14 17:05:16
    谁能用通俗的语言解释一下什么是 RPC 框架? - 远程过程调用协议RPC(Remote Procedure Call Protocol) 首先了解什么叫RPC,为什么要RPC,RPC是指远程过程调用,也就是说两台服务器A,B,一个应用部署在A服务器上,...
  • 什么是框架,框架的作用是什么?

    千次阅读 2015-04-27 10:30:23
    框架的作用: 代码重用:定义包、类、函数的放置和加载规则 请求的分发管理: 配置文件管理:加载和动态加载配置数据 错误和异常管理:异常捕捉、错误日志记录以及错误码规范 模板引擎:如何规划页面布局、widget如何...
  • 什么是框架?

    千次阅读 2020-07-10 20:09:34
    框架(Framework)一个框子——指其约束性,也一个架子——指其支撑性。 IT语境中的框架,特指为解决一个开放性问题而设计的具有一定约束性的支撑结构。在此结构上可以根据具体问题扩展、安插更多的组成部分,...
  • 什么是框架
  • MVC设计模式和MVC框架的区别

    千次阅读 多人点赞 2017-11-20 09:34:14
    MVC框架和MVC设计模式的区别
  • 什么是spring框架,spring框架究竟有什么用呢?我们可以用spring框架来做些什么呢?让我们来具体了解一下,以及经常所说的IOC和AOP是一种怎样的思想,到底是怎么实现这些思想的!
  • 框架学习:框架是什么以及框架怎么学

    万次阅读 多人点赞 2012-08-11 21:15:42
    框架就是framwork,百度上说框架是整个或部分系统的可重用性设计,应用开发者定制的应用骨架。我个人认为框架是一系列的底层服务,让应用开发者调用这一系列的底层服务来快速开发他们想要做的应用程序。 接下来要...
  • 什么是Java框架?Java框架有哪些?Java框架可以简化开发难度,便于我们更好的开发程序。所以学好Java框架还是比较重要的。下面就简要描述一下Java开发常用的四大框架,以此来分析。 什么是Java框架 JAVA框架就是一些类...
  • 前端框架存在的意义

    千次阅读 2017-11-23 17:30:48
    对于前端框架存在的意义?这个问题我思考了很久,稍微有一点头绪,把自己的想法说出来我感觉非常的爽,前端框架什么存在?这都我们应该考虑的问题。
  • 什么是设计模式?什么是框架?

    千次阅读 2009-01-20 10:26:00
    什么是设计模式?在生活和工作当中的各个方面,不断地重复一些事物和事情的方法,可以看作是一种设计模式,例如: ①小王家的茶几和小李家的茶几很像,但小王家的茶几用门代替了抽屉。 ②张三家的花园和李四家的花园...
  • 什么是前端框架与后端框架

    万次阅读 2017-05-22 10:11:40
    什么是框架框架(Framework)是整个或部分系统的可重用设计,表现为一组抽象构件及构件实例间交互的方法;另一种定义认为,框架是可被应用开发者定制的应用骨架。
  • Java集合容器面试题(2020最新版)

    万次阅读 多人点赞 2020-03-01 11:08:34
    文章目录集合容器概述什么是集合集合的特点集合和数组的区别使用集合框架的好处常用的集合类有哪些?List,Set,Map三者的区别?List、Set、Map 是否继承自 Collection 接口?List、Map、Set 三个接口存取元素时,各...
  • 什么是web框架

    千次阅读 2017-09-11 14:37:44
    Web 应用框架,或者简单的说是“Web 框架”,其实建立 web 应用的一种方式。从简单的博客系统到复杂的富 AJAX 应用,web 上每个页面都通过写代码来生成的。我发现很多人都热衷于学习 web 框架技术,例如 Flask ...

空空如也

1 2 3 4 5 ... 20
收藏数 1,150,484
精华内容 460,193
关键字:

什么是框架