精华内容
下载资源
问答
  • 1.2. Spring Boot框架出现的背景由于Spring是一个轻量级的企业开发框架,主要的功能就是用于整合和管理其他框架。但随着整合的框架越来越多,Spring的整合配置也日益繁琐。在这个情况下,Spring团体有了一个想法:...

    Spring Boot概述


    1.1. Spring Boot是什么

    Spring Boot是一套基于Spring框架的微服务框架。

    1.2. Spring Boot框架出现的背景

    由于Spring是一个轻量级的企业开发框架,主要的功能就是用于整合和管理其他框架。

    但随着整合的框架越来越多,Spring的整合配置也日益繁琐。在这个情况下,Spring团体有了一个想法:就是将平时主流使用到的框架的整合配置预先写好,然后通过简单的几个参数就可以实现框架的快速整合。

    这个想法催生Spring boot框架。

    我们将这个实现了各种主流框架与Spring的自动整合的框架。

    1.3. Spring Boot的作用是什么

    就是大大减少了Spring与其他框架整合的代码,也实现了Spring开发的Web应用的快速部署。(使用jar发布web应用)

    1.4. Spring Boot的特点

    1.实现了各种主流的框架的快速整合

    2.实现了Spring的应用的快速部署,使用Spring Boot的Web应用可以以Jar的方式部署。

    Spring是如何实现使用jar发布web 应用的呢?

    答:就是通过直接将tomcat服务器打包到我们的web应用里面实现了。

    1.5. Spring Boot学习的前提

    1.由于Spring Boot的最小配置都是基于SpringMVC框架的,所以学习Spring Boot先要有Spring和SpringMVC框架的基础。

    2.SpringBoot默认不推荐使用JSP视图,官方推荐使用Thymeleaf或者Freemarker模板引擎。本文档没有对这两个模板引擎作详细介绍。

    3.SpringBoot使用了Maven 或者Gradle管理需要的jar包,没有提供zip压缩包的发布形式,所以学习SpringBoot必须要学习Maven或者Gradle构建工具,现在主流使用的是Maven,所以学习Maven就可以了。

    4.Spring Boot中可以使用Spring框架的所有注解。如果没有学过纯注解Spring框架配置,需要先学习Spring纯注解的配置。

    所谓的纯注解:就是一个Spring配置文件都没有的配置。

    涉及Spring框架的纯注解配置类常用注解如下:

    73dae7baf5d1e73ee40cb5473dd67630.png

    1.6. Spring Boot准备工具

    学习Spring Boot建议使用Eclipse安装STS插件或者直接使用STS开发工具。

    下载官网:https://spring.io/tools/sts

    1.7. 参考资料

    本文档编写参考了

    1.Spring官方的示例代码,地址如下:

    https://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples

    2.SpringBoot官方参考文档,地址如下:

    https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#getting-started

    3.spring boot自动配置的框架,路径如下:

    https://github.com/spring-projects/spring-boot/tree/master/spring-boot-starters

    2. Spring Boot的入门

    2.1. 简单配置入门

    2.1.1. 配置流程

    1.新建一个maven项目

    7ed4cb80d47f2637a96a4934cceaa937.png

    2.填写创建项目的信息,注意使用jar的方式创建项目就可以

    7ed4cb80d47f2637a96a4934cceaa937.png

    --编写项目信息

    a4123e6f46d4045fbcf4922703fe8146.png

    3.到spring boot官方复制pom的依赖到pom.xml文件

    网站地址为:http://projects.spring.io/spring-boot/

    cd1ff3dc2bf132f3545cb8359b5f3d05.png

    --选择参数

    211c71f0d0651e19a60fed7575278c13.png

    pom.xml文件内容如下:

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>cn.gzsxt</groupId>
     <artifactId>spring-boot-demo-01</artifactId>
     <version>1.0</version>
     <parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>1.5.4.RELEASE</version>
     </parent>
     <dependencies>
     <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
     </dependencies>
    </project>

    注意:如果复制spring boot依赖到pom.xml报以下错误

    e53d7284e53f1176499af2155a80f4ff.png

    更新一下项目即可.如下图

    5d295bb1121806a187cdcab4fddd0aeb.png

    4.编写一个简单的Java类

    package hello;
    import org.springframework.boot.*;
    import org.springframework.boot.autoconfigure.*;
    import org.springframework.stereotype.*;
    import org.springframework.web.bind.annotation.*;
     
    //声明@Controller存储类型注解,表示SampleController类启动是,对象会加载到Spring容器
    @Controller
    //声明@EnableAutoConfiguration,表示程序使用Springboot默认的配置
    @EnableAutoConfiguration
    public class SampleController {
     /**
         * 表示如果访问路径/,返回字符串Hello World!
         */
     @RequestMapping("/")
     @ResponseBody
        String home() {
     return "Hello World!";
        }
     public static void main(String[] args) throws Exception {
     //启动Spring Boot程序
            SpringApplication.run(SampleController.class, args);
     
        }
    }

    5.启动Spring Boot程序

    12afaad273773d1caa721b464a40d54a.png

    6.启动成功,控制台提示我们使用8080端口访问

    0272a6634884979db7717b73ad96573e.png

    7.使用浏览器访问8080端口

    89c38eb0cf9f4be76763401dacbfa121.png

    2.1.2. 注意事项

    maven是需要联网下载的jar包的。注意一下网络是否畅通。

    因为SpringBoot是通过jar发布的。而jar的程序的入口是main方法。所以SpringBoot必须要提供一个类,可以从main方法启动项目。这个类就是SpringApplication

    SpringBoot框架是基于Spring框架的。我们知道Spring框架是通过加载配置类或者配置文件,创建容器,在将创建的对象放在容器里面。意味着SpringBoot也是必须需要配置类的。只是配置类已经内置实现了!!使用SpringApplication类启动程序,需要通过@EnableAutoConfiguration,表示自动加载默认的配置类。。

    2.2. 使用@SpringBootApplication注解配置

    上面的示例有一个问题,一个Controller需要手工配置一次,代码如下:

    SpringApplication.run(SampleController.class, args);

    问题:启动的Controller只有一个,如果一个项目需要将多个类扫描到Spring的容器中如何解决呢?

    答:使用@SpringBootApplication注解来配置。

    入口类使用@SpringBootApplication注解,启动项目时,SpringBoot框架会扫描入口类的加了@SpringBootApplication注解的入口类的同级目录和子目录的组件类的对象到Spring容器。

    2.2.1. 配置流程

    1.创建一个Maven项目

    d40aecdf8a113bf7af3cc28f19299455.png

    2.将Spring boot的依赖复制到pom.xml文件

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>cn.gzsxt</groupId>
     <artifactId>spring-boot-demo-02</artifactId>
     <version>1.0</version>
     <parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>1.5.4.RELEASE</version>
     </parent>
     <dependencies>
     <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
     </dependencies>
    </project>

    3.将项目简单分层

    d40aecdf8a113bf7af3cc28f19299455.png

    4.在cn.gzsxt文件夹下创建一个入口类Application.java

    package cn.gzsxt;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
     
    //使用SpringBoot自动配置程序
    @SpringBootApplication
    public class Application {
     
     public static void main(String[] args) {
     //执行当前类,根据@SpringBootApplication的配置,启动SpringBoot程序
            SpringApplication.run(Application.class, args);
        }
    }
     

    5.创建一个Controller,业务控制器

    package cn.gzsxt.controller;
     
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
     
    @Controller
    public class HelloController {
     
     @RequestMapping(value="/")
     @ResponseBody
     public String say(){
     //返回字符串
     return "HelloWorld!";
        }
    }
     

    6.启动项目,控制台返回访问端口

    ce8f747e1a86d83d97b1121a4a1bd7b2.png

    7.使用浏览器访问

    871e3f5cfb8f5f8ab94404d79d9046fa.png

    2.2.2. 注意事项

    1.为什么放在cn.gzsxt包下呢?

    答:@SpringBootApplication的配置默认根据入口类的所在位置扫描包以及入口类所在位置以及子包范围。

    根据以上配置,使用@SpringBootApplication配置Spring boot项目。会自动扫描cn.gzsxt.*下面HelloController类。

    从而可以得出使用@SpringBootApplication可以实现将多个类扫描到Spring容器里面。

    根据代码分析得到@SpringBootApplication做了三件事情:

    1. 声明当前类允许自动配置

    @EnableAutoConfiguration

    2. 声明当前类是一个配置类,因为扫描组件注解只能放在配置类上面

    @SpringBootConfiguration
    等同
    @Configuration

    3. 声明一个扫描组件注解,将所有组件类创建对象到容器

    @ComponentScan

    2.3. 热启动

    使用spring-boot:run命令启动项目,每次修改完成代码都要重新启动。是非常麻烦的。

    我们就有那么一个想法,能不能修改完代码,程序不用重启直接自动编译了?

    我们将修改完代码开发工具自动编译的过程称为,热启动。

    Spring boot是支持热启动的。只有加入以下依赖就可以

    <dependency> 
     <groupId>org.springframework.boot</groupId> 
     <artifactId>spring-boot-devtools</artifactId> 
           <!--
               optional=true,依赖不会传递,该项目依赖devtools;
               之后依赖该项目的项目如果想要使用devtools,需要重新引入
           -->
     <optional>true</optional> 
    </dependency>

    3. SpringBoot常见基础包说明

    5a67ee9960d1805705fa6886213f3cd6.png
    1.spring-boot-starter-web-1.5.4.RELEASE.jar:仅仅存放web项目需要的jar包的pom.xml
    2.spring-boot-starter-1.5.4.RELEASE.jar:仅仅存放springboot最小核心需要的jar包的pom.xml
    3.spring-boot-starter-logging-1.5.4.RELEASE.jar:仅仅存放日志输出需要的jar包的pom.xml
    4.spring-boot-1.5.4.RELEASE.jar:springboot框架核心包
    spring-boot-autoconfigure-1.5.4.RELEASE.jar:默认支持的自动配置的框架的配置包(重点)

    重点是spring-boot-autoconfigure包,因为spring boot的所有内置的自动配置的类都在里面!

    4. 常用API说明

    4.1. SpringApplication类

    4.1.1. 说明

    作用:用于启动Spring Boot的程序,根据传入的类声明的注解来决定不同的启动方式。

    4.1.2. 示例代码

    package cn.gzsxt;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
     
    //使用SpringBoot自动配置程序
    @SpringBootApplication
    public class Application {
     
     public static void main(String[] args) {
     //执行当前类,根据@SpringBootApplication的配置,启动SpringBoot程序
     SpringApplication.run(Application.class, args);
        }
    }

    4.2. @EnableAutoConfiguration注解

    4.2.1. 注解的声明

    @SuppressWarnings("deprecation")
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import(EnableAutoConfigurationImportSelector.class)
    public @interface EnableAutoConfiguration {
        String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
        Class<?>[] exclude() default {};
        String[] excludeName() default {};
    }

    4.2.2. 作用

    @EnableAutoConfiguration注解的作用是:启动程序时,告诉SpringApplication启动对象使用SpringBoot的默认配置。

    只要在SpringBoot项目的入口类配置了@EnableAutoConfiguration,在SpringBoot框架启动是就会自动根据你导入的jar包来加载spring-boot-autoconfigure-1.5.4.RELEASE-sources.jar中的xxxAutoconfiguration配置类,使用其默认配置。

    c3717bde86da67897314c33e369de85b.png

    4.2.3. 属性说明

    exclude属性:使用Class格式的方式,排除默认自动启动中不需要的配置类

    excludeName属性:使用类的限制名的方式,排序默认自动启动中不需要的配置类

    4.3. @SpringBootApplication注解

    4.3.1. 注解声明

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan(excludeFilters = {
     @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
     @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
    public @interface SpringBootApplication {
     @AliasFor(annotation = EnableAutoConfiguration.class, attribute = "exclude")
        Class<?>[] exclude() default {};
     @AliasFor(annotation = EnableAutoConfiguration.class, attribute = "excludeName")
        String[] excludeName() default {};
     @AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
        String[] scanBasePackages() default {};
     @AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
        Class<?>[] scanBasePackageClasses() default {};
    }

    根据注解的声明可以得出:@SpringBootApplication注解也是启动Springboot的默认配置。只是在@EnableAutoConfiguration注解的基础上增加了扫描包@ComponentScan的这个注解。实现了并且扫描指定范围的类创建对象到容器里面。

    4.3.2. 属性说明

    1.basePackages属性

    @SpringBootApplication默认扫描的范围是使用该注解的当前的类的包以及子包,如果要指定其他范围的包,可以是basePackages指定。

    2.basePackageClasses属性

    用于精确指定哪些类需要创建对象加载到Spring容器里面。

    3.exclude属性

    通过Class的方式排除不扫描的类,就是该类不创建对象。

    4.excludeName属性

    通过类的全限制名的方式,排除不扫描的类,指定的类不会在容器中创建对象。

    4.4. @AutoConfigureBefore注解

    4.4.1. 注解说明

    指定在SpringBoot框架自动配置的配置类执行完成之前,执行指定的自定义的配置类

    如果放在Application入口类,表示在所有自动配置的配置类还没有可以就先加载自定义的配置类。

    @AutoConfigureBefore注解属性:

    value:使用类的方式指定自动配置类

    name:使用类的全限制名(字符串)类指定配置类

    4.4.2. 示例代码

    1.创建一个普通的类,没有任何注解

    package cn.gzsxt.utils;
     
    /**
     * 创建一个没有扫描注入容器注解的类
     * @author ranger
     *
     */
    public class TestUtils {
     /**
         * 返回测试信息
         * @return
         */
     public String test(){
     return "-测试注入对象成功-";
        }
     
    }
     

    2.创建一个自定义配置类,注入普通的类到Spring容器

    package cn.gzsxt.config;
     
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
     
    package cn.gzsxt.config;
     
    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
     
    import cn.gzsxt.utils.TestUtils;
     
    /**
     * 创建一个自定义的配置类
     * @author ranger
     *
     */
    @Configuration
    public class MyConfiguration {
     /**
         * 返回一个对象到容器
         * @return
         */
     @Bean(name="testUtils")
     //表示如果Spring容器有TestUtils的对象就不执行这个方法在创建一次了。
     @ConditionalOnMissingBean(TestUtils.class)
     public TestUtils getTestUtils(){
            TestUtils testUtils=new TestUtils();
     return testUtils;
        }
     
    }
     

    3.在入口类配置加入自定义配置类

    package cn.gzsxt;
     
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.AutoConfigureBefore;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
     
    import cn.gzsxt.config.MyConfiguration;
     
    //使用SpringBoot自动配置程序
    @SpringBootApplication
    //在自动配置的配置类之前启动自定义的配置类
    @AutoConfigureBefore(value=MyConfiguration.class)
    public class Application {
     
     public static void main(String[] args) {
     //执行当前类,根据@SpringBootApplication的配置,启动SpringBoot程序
            SpringApplication.run(Application.class, args);
     
        }
     
    }
     

    4.在Controller里面使用这个注入的对象

    package cn.gzsxt.controller;
     
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
     
    import cn.gzsxt.utils.TestUtils;
     
    @Controller
    public class HelloController {
     
     @Autowired
     private TestUtils testUtils;
     
     @RequestMapping(value="/")
     @ResponseBody
     public String say(){
            System.out.println(testUtils.test());
     return testUtils.test();
        }
     
    }
     

    5.测试,成功

    6c0dc2c5d0bf19236aeaa498d75b13ef.png

    4.5. @AutoConfigureAfter注解

    指定在SpringBoot框架自动配置的配置类执行完成之后,然后执行指定的自定义的配置类。

    4.6. @SpringBootTest注解

    4.6.1. 注解说明

    用于使用JUnit测试SpringBoot程序,启动SpringBoot框架。测试SpringBoot一定要加上。

    4.6.2. 示例代码

    package cn.gzsxt.test;
     
    import java.sql.SQLException;
     
    import javax.sql.DataSource;
     
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
     
    @RunWith(SpringJUnit4ClassRunner.class)
     
    //如果不加该注解,无法启动SpringBoot
    @SpringBootTest
    public class DataSourceTest {
     
     @Autowired
     private DataSource dataSource;
     
     @Test
     public void dataSource() {
     try {
                System.out.println(dataSource.getConnection());
            } catch (SQLException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
            }
        }
     
    }
     

    5. SpringBoot配置流程(重点)

    5.1. 概述

    Spring Boot框架是一个将整合框架的整合代码都写好了的框架。所以我们要知道它的工作原理才能够,找到各种整合框架可以配置的属性,以及属性对应的属性名。

    本章主要讲述如何在SpringBoot框架代码中找到application.properties配置文件的属性值。

    5.2. 配置流程说明

    1.SpringBoot的spring-boot-autoconfigure-1.5.4.RELEASE.jar中编写了所以内置支持的框架的自动整合代码

    2.所以支持的框架根据功能类型来划分包,每个包都有一个XxxxAutoConfiguration配置类,都是一个基于纯注解的配置类,是各种框架整合的框架代码。如图所示:

    20e7dc8eb7815e63c9ddf8aa130148f5.png

    3.如果配置的框架有默认的配置参数,都放在一个命名为XxxxProperties的属性,如图所示

    57d392dc285a77da9fa8930035cecc05.png

    4.通过项目的resources下的application.properties文件可以修改每个整合框架的默认属性,从而实现了快速整合的目的。

    ccd81efa89d81ba209d056d144f20dae.png

    5.3. 配置流程图

    第一步:配置一个内置整合框架的参数,先到spring-boot-autoconfigure-1.5.4.RELEASE.jar找到对应的模块。

    第二步:如果该框架有可以配置的参数,那么对应的整合模块中一定有一个XxxxProperties类,在里面可以找可以设置的参数。

    第三部:在resources源目录下的application.properties文件里面可以修改XxxxProperties类中默认的参数。

    配置流程如下:

    0d2d76483cbdff4c060856a3e64771ce.png

    6. 配置文件

    Spring Boot的参数配置文件支持两种格式。分别为application.propertie,application.yml。

    配置Spring Boot时可以二选一。

    application.propertie:是键值对风格
    application.yml:是层级键值对风格

    6.1. application.propertie配置文件

    6.1.1. application.propertie说明

    默认情况下,Spring Boot会加载resources目录下的application.properties来获得配置的参数。

    6.1.2. application.propertie多配置文件支持

    1.在application.properties配置文件下,增加多个application-xxx.properties文件名的配置文件,其中xxx是一个任意的字符串。

    例如:

    application-database.properties
    application-mvc.properties
    application-freemarker.properties

    2.在application.properties总配置文件指定,加载的多个配置文件

    例如:要同时使用,四个配置文件

    application.properties、
    application-database.properties
    application-mvc.properties
    application-freemarker.properties

    那么在application.properties其他配置文件指定为:

    spring.profiles.active=database,mvc,freemarker

    6.2. application.yml配置文件

    6.2.1. application.yml说明

    SpringBoot支持一种由SpringBoot框架自制的配置文件格式。后缀为yml。yml后缀的配置文件的功能和properties后缀的配置文件的功能是一致的。配置时可以二选一。

    例如:配置文件:application.properties

    #配置数据源
    spring.datasource.url=jdbc:mysql://localhost:3306/school
    spring.datasource.driverClassName=com.mysql.jdbc.Driver
    spring.datasource.username=root
    spring.datasource.password=123456
    spring.datasource.type=org.apache.commons.dbcp2.BasicDataSource
    #spring-data-jpa配置
    #显示SQL语句
    spring.jpa.show-sql=true
    #表示是否需要根据view的生命周期来决定session是否关闭
    spring.jpa.open-in-view=true

    可以修改为配置文件:application.yml,内容为:

    #配置数据源
    spring:
     datasource:
     url: jdbc:mysql://localhost:3306/school
     driverClassName: com.mysql.jdbc.Driver
     username: root
     password: 123456
     #配置连接池
     type: org.apache.commons.dbcp2.BasicDataSource
     #配置JPA的属性 
     jpa:
     show-sql: true
     open-in-view: true

    其实application.yml配置文件就是将原来application.properties使用(.)分割的方式,改为树状结构,使用(:)分割。

    注意:key的字段与值之间的冒号(:)后面一定要有一个空格。

    6.2.2. application.yml多配置文件支持

    1.在application.yml配置文件下,增加多个application-xxx.yml文件名的配置文件,其中xxx是一个任意的字符串。

    例如:

    application-database.yml
    application-mvc.yml
    application-freemarker.yml

    2.在application.yml总配置文件指定,加载的多个配置文件

    例如:要同时使用,四个配置文件

    application.yml
    application-database.yml
    application-mvc.yml
    application-freemarker.yml

    那么在application.yml其他配置文件指定为:

    spring:
       profiles:
         active: database,mvc,freemarker

    6.3. 配置示例-Spring数据源配置

    配置Spring数据源,并支持DBCP2数据源

    1.在pom.xml加入支持数据源的类库

     <!-- 数据库驱动 -->
     <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     </dependency>
     <!-- dbcp2连接池 -->
     <dependency>
     <groupId>org.apache.commons</groupId>
     <artifactId>commons-dbcp2</artifactId>
     </dependency>
      <!-- Springboot测试包 -->
     <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-test</artifactId>
     </dependency>

    2.找到数据源的配置类

    dfca75ecfce608ed6f8f14b894920925.png

    3.数据源的配置类的属性如下

                                           //注意这里
    @ConfigurationProperties(prefix = "spring.datasource")
    public class DataSourceProperties
     implements BeanClassLoaderAware, EnvironmentAware, InitializingBean {
     
     private ClassLoader classLoader;
     private Environment environment;
     private String name = "testdb";
     private boolean generateUniqueName;
         //注意这里
        private Class<? extends DataSource> type;
        private String driverClassName;
        private String url;
        private String username;
        private String password;
     private String jndiName;
     private boolean initialize = true;
     private String platform = "all";
     private List<String> schema;
     private String schemaUsername;
     private String schemaPassword;
     private List<String> data;
     private String dataUsername;
     private String dataPassword;
     private boolean continueOnError = false;
     private String separator = ";";
     private Charset sqlScriptEncoding;
     private EmbeddedDatabaseConnection embeddedDatabaseConnection = EmbeddedDatabaseConnection.NONE;
     private Xa xa = new Xa();
     private String uniqueName;

    3.application.properties配置文件修改数据源参数:

    #datasource
    spring.datasource.url=jdbc:mysql://localhost:3306/school
    spring.datasource.driverClassName=com.mysql.jdbc.Driver
    spring.datasource.username=root
    spring.datasource.password=123456
    #support dbcp2 datasource
    spring.datasource.type=org.apache.commons.dbcp2.BasicDataSource

    1.spring.datasource这个前缀就是DataSourceProperties的@ConfigurationProperties(prefix = "spring.datasource")注解声明的前缀

    2.属性就是DataSourceProperties对应的属性

    4.测试代码

    package cn.gzsxt.test;
    import java.sql.SQLException;
    import javax.sql.DataSource;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
     
    @RunWith(SpringJUnit4ClassRunner.class)
    //SpringBoot测试要加上这个注解
    @SpringBootTest
    public class DataSourceTest {
     
     @Autowired
     private DataSource dataSource;
     
     @Test
     public void dataSource() {
     try {
                System.out.println(dataSource.getConnection());
            } catch (SQLException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
            }
        }
    }

    注意事项:

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>cn.gzsxt.springboot</groupId>
     <artifactId>springboot-demo-06-dbcp2</artifactId>
     <version>1.0</version>
     
     <!-- 设置项目信息 -->
     <properties>
     <!-- 设置源代码的编码 -->
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <!-- 输出的字节码的编码 -->
     <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
     <!-- 设置JDK的版本 -->
     <java.version>1.8</java.version>
     </properties>
     <!-- Spring Boot依赖的父包,包括框架基础包的配置 -->
     <parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>1.5.4.RELEASE</version>
     
     </parent>
     
     
     <dependencies>
     <!-- 导入依赖的Web模块SpringMVC的配置 -->
     <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
     
     <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-devtools</artifactId>
     <!-- optional=true,依赖不会传递,该项目依赖devtools; 之后依赖该项目的项目如果想要使用devtools,需要重新引入 -->
     <optional>true</optional>
     </dependency>
     
     <!-- dbcp2依赖包 -->
     
     <dependency>
     <groupId>org.apache.commons</groupId>
     <artifactId>commons-dbcp2</artifactId>
     
     </dependency>
     <!-- mysql driver -->
     
     <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     </dependency>
     
     <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-test</artifactId>
     </dependency>
     <!-- jdbc -->
            <!-- SpringBoot配置jdbc模块,必须导入JDBC包的 -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
            </dependency>
     
     </dependencies>
     
     
     
    </project>

    6.4. 获得自定义application.properties声明的属性值

    使用@ConfigurationProperties注解可以直接获得application.properties配置的属性值。

    @ConfigurationProperties属性说明:
    prefix属性:表示获得application.properties时忽略的指定的前缀,如:
    @ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
    ignoreUnknownFields属性:忽略未知的字段值。如果为true时,就是当application.properties设置的输入找不到对应的字段时,就忽略它。

    @ConfigurationProperties的使用:

    1.在pom.xml导入支持的依赖包

     <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-configuration-processor</artifactId>
     <optional>true</optional>
     </dependency>

    2.自定义一个TestProperties 属性类

    package cn.gzsxt.utils;
     
    import org.springframework.boot.context.properties.ConfigurationProperties;
     
    @ConfigurationProperties(prefix="cn.gzsxt" )
    public class TestProperties {
     private String path;
     
     public String getPath() {
     return path;
        }
     
     public void setPath(String path) {
     this.path = path;
        }
    }

    3.自定义一个application-test.properties文件

    cn.gzsxt.path=demo-03

    4.在application.properties指定application-test.properties配置文件

    spring.datasource.url=jdbc:mysql://localhost:3306/school
    spring.datasource.driverClassName=com.mysql.jdbc.Driver
    spring.datasource.username=root
    spring.datasource.password=123456
    spring.datasource.type=org.apache.commons.dbcp2.BasicDataSource
    spring.profiles.active=test

    5.启动支持TestProperties类自动配置

    在入口类Application增加EnableConfigurationProperties注解支持

    package cn.gzsxt;
     
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
     
    import cn.gzsxt.utils.TestProperties;
     
    @SpringBootApplication
    @EnableConfigurationProperties(value=TestProperties.class)
    public class Application {
     
     public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    }
     

    6.调用配置的属性path

    package cn.gzsxt.controller;
    import java.util.HashMap;
    import java.util.Map;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
     
    import cn.gzsxt.service.StudentService;
    import cn.gzsxt.utils.TestProperties;
     
    @Controller
    public class StudentController {
     
     @Autowired
     private TestProperties testProperties;
     
     @RequestMapping(value="/path")
     public String path(){
            System.out.println(testProperties.getPath()+"==============");
     return "index";
        }
    }

    7.测试结果

    b37108fe615c5306aff19123cae177af.png

    7. Spring Boot视图

    7.1. 视图概述

    由于SpringBoot建议使用jar的方式发布web程序。所以不建议使用jsp视图,也不对jsp视图做默认的支持。

    如果确实要使用JSP视图发布Spring Boot的应用,那么需要使用war的方式发布。

    Spring Boot默认自动配置支持视图是以下的模板引擎:

    • Thymeleaf
    • FreeMarker
    • Groovy
    • Mustache

    7.2. FreeMarker模板引擎的配置

    7.2.1. 配置流程

    1.在pom.xml导入FreeMarker模板引擎依赖的包

     <!-- freemarker支持包 -->
     <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-freemarker</artifactId>
     </dependency>

    2.Spring Boot的模板引擎的默认路径是resources/templates,所以在resources下创建一个templates文件夹。将视图页面放在里面

    c80495d1058315bc4015417092c98a41.png

    3.这样Spring Boot直接就支持了返回freemarker的ftl视图了。

     @RequestMapping(value="/index")
     public String index(Model model,HttpSession session){
            System.out.println("-测试插入数据-");
            Map<String, Object> entity=new HashMap<String, Object>();
     //插入数据
     entity.put("sname", "test3");
     studentService.insert(entity);
       //返回index就会跳到index.ftl
     return "index";
        }

    4.根据需要可以在resources的application.properties配置文件,修改freemarker视图的默认属性。

    82260caf3d0122c24f62f3b0c050de13.png

    例如:

    1.application.properties配置文件增加以下配置

    #setting freemarker encoding
    spring.freemarker.charset=UTF-8

    7.2.2. 注意事项

    注意Freemarker的自动配置的属性类为:spring-boot-autoconfigure-1.5.4.RELEASE.jar包的

    org.springframework.boot.autoconfigure.freemarker.FreeMarkerProperties类。

    freemarker视图的默认属性配置在里面

    如下:

    package org.springframework.boot.autoconfigure.freemarker;
     
    import java.util.HashMap;
    import java.util.Map;
     
    import org.springframework.boot.autoconfigure.template.AbstractTemplateViewResolverProperties;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    @ConfigurationProperties(prefix = "spring.freemarker")
    public class FreeMarkerProperties extends AbstractTemplateViewResolverProperties {
       //默认的视图的存放路径
     public static final String DEFAULT_TEMPLATE_LOADER_PATH = "classpath:/templates/";
      //默认的前缀
     public static final String DEFAULT_PREFIX = "";
     //默认的后缀
     public static final String DEFAULT_SUFFIX = ".ftl";
     private Map<String, String> settings = new HashMap<String, String>();
     private String[] templateLoaderPath = new String[] { DEFAULT_TEMPLATE_LOADER_PATH };
     private boolean preferFileSystemAccess = true;
     
     public FreeMarkerProperties() {
     super(DEFAULT_PREFIX, DEFAULT_SUFFIX);
        }
     
     public Map<String, String> getSettings() {
     return this.settings;
        }
     
     public void setSettings(Map<String, String> settings) {
     this.settings = settings;
        }
     
     public String[] getTemplateLoaderPath() {
     return this.templateLoaderPath;
        }
     
     public boolean isPreferFileSystemAccess() {
     return this.preferFileSystemAccess;
        }
     
     public void setPreferFileSystemAccess(boolean preferFileSystemAccess) {
     this.preferFileSystemAccess = preferFileSystemAccess;
        }
     
     public void setTemplateLoaderPath(String... templateLoaderPaths) {
     this.templateLoaderPath = templateLoaderPaths;
        }
     
    }
     

    2.查看Spring Boot内置的FreeMarkerProperties类的属性,发现application.properties里面可以设置的属性竟然比FreeMarkerProperties定义的属性多,为什么呢?

    答:因为Spring Boot直接引用了FreeMarker框架原来内部定义的属性,只是在前面加一个前缀。

    所以导致有一些没有默认值的属性不在FreeMarkerProperties类里面。

    7.3. Thymeleaf模板引擎的配置

    7.3.1. 配置流程

    1.导入Thymeleaf的支持包

     <!-- thymeleaf支持包 -->
     <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-thymeleaf</artifactId>
     </dependency>

    2.Spring Boot的Thymeleaf模板引擎的默认路径是resources/templates,所以在resources下创建一个templates文件夹。将视图页面放在里面

    1faf98274647991243046ea54af5fbdf.png

    内容为:

    <!DOCTYPE HTML>
    <!-- 注意Thymeleaf模板引擎一定要引入xmlns:th="http://www.thymeleaf.org"命名空间 -->
    <html xmlns:th="http://www.thymeleaf.org">
    <head>
     <title>hello</title>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    </head>
    <body>
    <!-- ${name}用于获得Controller返回的Request的取值范围的值,${}一定要在th:开头的标签里才有效 -->
    <p th:text="'Hello!, ' + ${name} + '!'" >3333</p>
    </body>
    </html>

    3.这样Spring Boot直接就支持了返回Thymeleaf的html视图了。

     @RequestMapping(value="/index")
     public String index(Model model){
            System.out.println("-测试数据-");
     model.addAttribute("name", "张三");
     return "index";
        }
     

    4.根据需要可以在resources的application.properties配置文件,增加Thymeleaf视图的默认属性。

    spring.thymeleaf.mode=HTML5
    spring.thymeleaf.encoding=UTF-8
    spring.thymeleaf.content-type=text/html
    #开发时关闭缓存,不然没法看到实时页面
    spring.thymeleaf.cache=false

    7.3.2. 注意事项

    具体的application-thymeleaf.properties配置文件能够配置的属性,根据自身实际的情况,

    可以查看spring-boot-autoconfigure-1.5.4.RELEASE.jar设置。

    Thymeleaf的属性类为:org.springframework.boot.autoconfigure.thymeleaf.ThymeleafProperties

    2adb6e3ba57b0476104007c7f084aabd.png

    7.4. JSP视图配置(极不推荐)

    Spring Boot在默认自动配置已经不支持JSP视图。如果非要使用JSP视图。需要我们手工配置。

    7.4.1. 配置流程

    7.4.2. 注意事项

    1.因为JSP是JavaWEB技术,依赖Servlet-API。所以如果使用jsp视图发布包格式为war包

    2.也是因为JSP是依赖Servlet-API的,所以一定要实现一个SpringBootServletInitializer类的子类作为项目的入口,功能类似于web项目的web.xml

    不管使用任何的模板引擎代替JSP。其实就可以认为它是类似于JSP的动态页面技术。

    就是将原来JSP实现的功能,换一种方式来编写。。。

    7.5. 默认读取的静态资源路径

    Spring Boot默认读取CSS、JavaScript、html、图片等静态资源的根目录为:

    classpath:/META-INF/resources/
    classpath:/resources
    classpath:/static/
    classpath:/public/
     

    也就是说html使用到的CSS、image等静态资源可以放到以上目录文件夹

    例如:

    736082545f1ec0999a1d8f53d5e728db.png

    注意:具体查看org.springframework.boot.autoconfigure.web.ResourceProperties类的配置,如果要修改,在appplication.properties修改默认的路径。

    0d097152e9e060e6b0097930f14f7178.png
    展开全文
  • Java web开发是什么?Java web开发,是用Java技术来解决相关web互联网领域的技术总和。web包括:web服务器和web客户端两部分。Java在客户端的应用有java applet,不过...Java web 开发Java web开发学习路线一:入...

    ​Java web开发是什么?

    Java web开发,是用Java技术来解决相关web互联网领域的技术总和。web包括:web服务器和web客户端两部分。Java在客户端的应用有java applet,不过使用得很少,Java在服务器端的应用非常的丰富,比如Servlet,JSP和第三方框架等等。Java技术对Web领域的发展注入了强大的动力。

    b841ea7844bc2bc81af666fff1dd24d7.png

    Java web 开发

    Java web开发学习路线

    一:入门阶段

    学习目标:Java程序员

    1:熟悉jdk,jvm,eclipse,安装于配置jdk

    2:熟悉并掌握java的基础语法,类,抽象类,接口,内部类等概念

    3: java核心编程,如输入输出流,多线程,集合,XML,正则表达式等

    4:java图形化编程,如awt,swing

    5:java网络编程,Applet,Socket,TCP/IP,NIO等

    6:java高级特性,如反射,泛型,自动装箱与拆箱等

    152c20c7debef24540106324f8fe9881.png

    二:提高阶段

    学习目标:java初级软件工程师

    1:网页开发技术,如HTML,CSS,JavaScript,AJAX

    2:java与数据库开发技术,如SQL,MySql,Oracle,SQL Server,JDBC

    3:JavaWeb核心开发技术,如JavaBean,Servlet,EL等

    三:加强阶段

    学习目标:Java中级软件工程师

    1:Hibernate框架

    2:iBATIS框架

    3:Struts1框架

    4:Struts2框架

    5:Spring业务层框架

    四:进阶阶段

    学习目标:Java高级软件工程师

    1:Java Web企业级开发技术,如会话Bean,消息驱动Bean

    2:Java Web分布式开发技术,如JTA,JAAS,JNDI

    3:Java Web开源技术与框架,如工作流,规则引擎,缓存,报表

    五:高级阶段

    学习目标:Java系统架构师

    1:Java与UML,如对象图,用例图,组件图,部署图

    2:Java设计模式:外观、适配单观察者、装饰等

    3:Web服务架构:WebService,SCA,SOA,ESB,EAI

    4:面向资源架构:ROA,REST

    5:面向云架构:COA、SaaS、分布式计算、云计算

    最后,愿大家都能成为优秀的Java web开发工程师

    新手如何学习Java三大框架?

    框架是程序员们必学的知识点,而且是十分重要的应用,Spring、Struts、Hibernate也是经典中的经典,最常用的框架类型。

    作为Java新手应该如何去学习呢?小编搜集了很多网友的建议,现在为大家总结如下:

    有同学建议:对于Spring来说,最应该学习的就是Spring的IOC原理,这在使用过程中是必须要理解的、必会的。用配置文件或者是Annonation的方式来代替New创建实例,可以说这是一个历史性的进步,并且前进了一大步,影响深远。也是间接的促成了接口实现分离的优雅风格。另外,该同学还认为,建议把Hibernate换成Mybatis。

    还有更接地气的同学建议说:从配置文件开始,理解三个字母各自是如何工作的,以及是如何协同工作的。我从零开始学ssi的时候就这么干的,花了一个月左右,使用起来就比较熟练了。然后深入框架的一些高级用法。再接着琢磨它们的原理、思想和设计、实现。最后到能自己重新发明轮子。

    更有给力的同学给出了详细的建议,连具体步骤都给出了明确的说明。具体如下:1. java语法基础,可以看think in java 2. servlet,jsp,jdbc,结合html,css,js实现自己想要的小网站,功能慢慢积少成多。3. spring,springmvc,springdata,hibernate等框架学习,一上来用这些框架忽略基础,这样会出现只会用xxx框架,换个yyy框架又得重新学习的感觉。4.设计模式,aop,oop等的学习,当然可以和之前的步骤反复来研究提高。

    对于具体的操作,很多有经验的小伙伴也有妙招:其实不外乎实操这一真理,就是亲自去写一些框架,实践出真知,只有实际操作过了才能真正理解那些曾经学过的知识都是怎么回事。比如这位朋友建议写一些通过JDBC直接到数据库读写数据的代码,写一个简单的web app,可以登记用户,要对数据有效性能控制,要能检测错误。然后再想办法优化成spring, hibernate和struts。优化到代码越少越好。实操之后最重要的就是思考,每做完一个项目就做一次总结,动脑多想想为什么、接下来怎么做,那么框架那点事儿就不叫事儿了。

    以上就是小编为大家总结的关于学习三大框架的一些技巧和方法,尤其对于初学者最为重要。还是那句话,学得再多不如一次实操,边学边练是永远不变的真理,也只有这样才能真正的学到东西,才能真正的把知识转化为技能从而转化为自己的财富。如果你曾经也是一名Java编程初学者,如果你有更好的建议,欢迎留言讨论,独乐乐不如众乐乐。

    希望所有Java初学者都能顺利入门,真正掌握一门技能。

    原文链接:

    JavaWeb开发学习路线及Java三大框架分享mp.weixin.qq.com
    54a4da05adbe85919239e11fd75945bf.png

    b88fafcd89393be8defd60ed35569ac3.png

    cc58f05135a7c5a8cbe9f5e618fa469a.png
    展开全文
  • 身为一个程序员,对我们来说重要的一个特性是什么?不善言谈?...身为刚刚毕业的一个大学生,虽然没有大佬的知识渊博,但总想将自己的学习笔记记录下来,每一个技术点都整理下来,总有后来之辈能够用...

    6a603fc655afbb0f29b28464f02c866a.png

    身为一个程序员,对我们来说重要的一个特性是什么?不善言谈?NO!钢铁直男(女)?NO!认真负责?NO!一个优良的传统就是:分享!相信没有哪一个行业,能跟程序员一样敢于分享自己的技术,敢于分享自己的观点的了!各大技术网站总能看到篇篇详细的技术博客,共同进步才是技术的真正的提升!

    身为刚刚毕业的一个大学生,虽然没有大佬的知识渊博,但总想将自己的学习笔记记录下来,每一个技术点都整理下来,总有后来之辈能够用到!

    今天的java学习笔记是:spring框架。

    64af640c9f44463e5f7db031601a9749.png

    1、什么是Spring框架?Spring框架有哪些主要模块?

    Spring框架是一个为Java应用程序的开发提供了综合、广泛的基础性支持的Java平台。Spring帮助开发者解决了开发中基础性的问题,使得开发人员可以专注于应用程序的开发。Spring框架本身亦是按照设计模式精心打造,这使得我们可以在开发环境中安心的集成Spring框架,不必担心Spring是如何在后台进行工作的。

    Spring框架至今已集成了20多个模块。这些模块主要被分如下图所示的核心容器、数据访问/集成,、Web、AOP(面向切面编程)、工具、消息和测试模块。

    2b2f039d43f42f578cb30c8b0cdd5160.png

    spring学习视频教程领取:

    2、使用Spring框架能带来哪些好处?

    下面列举了一些使用Spring框架带来的主要好处:

    Dependency Injection(DI) 方法使得构造器和JavaBean properties文件中的依赖关系一目了然。

    与EJB容器相比较,IoC容器更加趋向于轻量级。这样一来IoC容器在有限的内存和CPU资源的情况下进行应用程序的开发和发布就变得十分有利。

    Spring并没有闭门造车,Spring利用了已有的技术比如ORM框架、logging框架、J2EE、Quartz和JDK Timer,以及其他视图技术。

    Spring框架是按照模块的形式来组织的。由包和类的编号就可以看出其所属的模块,开发者仅仅需要选用他们需要的模块即可。

    要测试一项用Spring开发的应用程序十分简单,因为测试相关的环境代码都已经囊括在框架中了。更加简单的是,利用JavaBean形式的POJO类,可以很方便的利用依赖注入来写入测试数据。

    Spring的Web框架亦是一个精心设计的Web MVC框架,为开发者们在web框架的选择上提供了一个除了主流框架比如Struts、过度设计的、不流行web框架的以外的有力选项。

    Spring提供了一个便捷的事务管理接口,适用于小型的本地事物处理(比如在单DB的环境下)和复杂的共同事物处理(比如利用JTA的复杂DB环境)。

    今天的技术笔记分享结束,欢迎小伙伴持续关注!

    a27858e9027d407becbfd24dba7e8a01.png
    展开全文
  • 原标题:Java学习心得及学习顺序刚开始学习java时间不长,感觉有点不知道怎么学习...Java学习顺序及计划第一阶段:Java基础,包括java语法,面向对象特征,常见API,集合框架;第二阶段:java界面编程,包括AWT,事...

    原标题:Java学习心得及学习顺序

    刚开始学习java时间不长,感觉有点不知道怎么学习,不知到按照怎样的顺序学习,后来请教了一些已经工作的大神,他告诉我一定要按照阶段性学习,一个阶段一阶段打好基础。虽然很多网站都有很多学习视频,但还是给不知道的新手分享一下吧。

    Java学习顺序及计划

    第一阶段:Java基础,包括java语法,面向对象特征,常见API,集合框架;

    第二阶段:java界面编程,包括AWT,事件机制,SWING,这个部分也可以跳过,用的时候再看都能来及;

    第三阶段:java API:输入输出,多线程,网络编程,反射注解等,java的精华部分;

    第四阶段:数据库SQL基础,包括增删改查操作以及多表查询;

    第五阶段:JDBC编程:包括JDBC原理,JDBC连接库,JDBC API,虽然现在Hibernate比JDBC要方便许多,但是JDBC技术仍然在使用,JDBC思想尤为重要;

    第六阶段:JDBC深入理解高级特性:包括数据库连接池,存储过程,触发器,CRM思想;

    第七阶段:HTML语言学习,包括HTML标签,表单标签以及CSS,这是Web应用开发的基础;

    第八阶段:Java脚本语言,包括java语法和对象,就这两个方面的内容;

    第九阶段:DOM编程,包括DOM原理,常用的DOM元素以及比较重要的DOM编程思想;

    第十阶段:Servlet开发,从此开始踏入java开发的重要一步,包括XML,Tomcat服务器的安装使用操作,HTTP协议简单理解,Servlet API等,这个是java web开发的基础;

    第十一阶段:JSP开发:JSP语法和标签,自定义标签,EL,JSTL库了解以及MVC三层架构的设计模式理念;

    第十二阶段:AJAX开发:AJAX原理,请求响应处理,AJAX开发库;

    第十三阶段:轻量级框架,三大框架之一Struts框架的学习,自此踏入java web开发的精华部分,包括Struts体系架构,各种组件,标签库和扩展性的学习;

    第十四阶段:Hibernate框架学习,三大框架之一,包括检索映射技术,多表查询技术,缓存技术以及性能方面的优化;

    第十五阶段:Spring框架的学习,三大框架之一,包括了IOC,AOP,DataSource,事务,SSH集成以及JPA集成;

    Java技术干货:www.csnewer.com返回搜狐,查看更多

    责任编辑:

    展开全文
  • java框架学习系列

    2019-09-20 22:45:03
    这篇文章的目的主要是作为一个框架学习的索引,方便查找及顺序学习 一.struts2学习 1.java之struts框架入门教程 2.java之struts2的执行流程讲解 3.java之struts2的配置讲解 4.java之struts2的action的创建方式 ...
  • java框架学习路线总结

    千次阅读 2019-03-13 00:05:29
    java基础学习完的我,现在开始着手准备学框架了,下面我总结一下如何学习后端java web框架,自己也看了很多博文,所以通过融会贯通表达一下我的学习路线。 有很多博主都说学习structs,Hibernate,spring mvc要按照...
  • 在前两章中,我们先阅读分析和同步相关的JVM源码,再修改源码把关键参数Policy和QMode打印出来,对锁的抢占和释放有了清楚认识,这里结合NotifyDemo.java源码对我们之前的分析做个回顾,NotifyDemo.java源码在github...
  • JUC框架学习顺序

    千次阅读 2019-06-05 17:18:57
    Java concurrent包提供了很多高性能的并发类,类的设计思路及源码值得我们学习参考,但在学习其原理过程中,作者经常碰到这种情况,在学习ConcurrentHashMap时,里面的部分方法操作牵扯到其他类,例如Unsafe、...
  • java学习顺序

    2009-04-29 11:18:00
    java学习顺序应该是这样的! javaSE(java基础) servlet(JSP基础) JDBC(JSP和javaEE基础) JSP(javaEE基础) jstl(javaEE的web标签基础) 然后需要学习一些设计模式的知识 比如Dao,Manager等等作为三大框架...
  • 用于开启AOP注解 @Component @Aspect @EnableAspectJAutoProxy public class LoggerAspect { //各种通知及逻辑 } 通知的执行顺序 我们发现如果使用xml配置文件实现AOP,通知的执行顺序与配置文件中的配置顺序有关,...
  • JAVA学习顺序

    2016-02-25 09:31:36
    建议如果学习java体系的话可以这样去学习:  *第一阶段:Java基础,包括java语法,面向对象特征,常见API,集合框架;  *第二阶段:java界面编程,包括AWT,事件机制,SWING,这个部分也可以跳过,用的时候再看...
  • java集合概述 与数组的区别: 1、数组长度是固定的,并且同一个数组只能存放类型一样的数据...LinkedList 链表存储(非连续的,非顺序的) ArrayList执行查询操作效率比较高。 LinkedList插入、删除操作效率比较高。
  • 刚开始学习java时间不长,感觉有点不知道怎么学习,不知...Java学习顺序及计划 第一阶段:Java基础,包括java语法,面向对象特征,常见API,集合框架; 第二阶段:java界面编程,包括AWT,事件机制,SWING,这个部分...
  • Java学习顺序

    2013-07-15 10:24:22
    建议如果学习java体系的话可以这样去学习:  *第一阶段:Java基础,包括java语法,面向对象特征,常见API,集合框架;  *第二阶段:java界面编程,包括AWT,事件机制,SWING,这个部分也可以跳过,用的时候再看...
  • 补充说明一下:我觉得学习java比较合适的方法是先把所有的知识点过一遍,然后把所有的知识点串起来,边做开发边补充,就像写文章一样,先写好框架,然后再去润色填充。因为前期在学习的时候你不知道用在哪里,不知道...
  • 补充说明一下:我觉得学习java比较合适的方法是先把所有的知识点过一遍,然后把所有的知识点串起来,边做开发边补充,就像写文章一样,先写好框架,然后再去润色填充。因为前期在学习的时候你不知道用在哪里,不知道...
  • java学习顺序

    2010-07-22 18:00:00
    J2SE(Thinking in java+视频)---->J2EE专题研究(敲打练习)---->框架源代码的研究
  • java-koans, 按照逻辑顺序学习java语法和习惯用法的框架和课程 Java Koans 运行指令:下载并取消对最新的java-koans中的内容进行以下操作: https://github.com/matyb/java-koans/archive/master.zip将终端和光盘...
  • J.U.C框架学习顺序

    千次阅读 2016-10-09 17:53:05
    背景 Java concurrent包提供了很多高性能的并发类,类的设计思路及源码值得我们学习参考,但在学习其原理过程中,作者经常碰到这种情况,在学习ConcurrentHashMap时,里面的部分方法操作牵扯到其他类,例如Unsafe、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 533
精华内容 213
关键字:

java框架学习顺序

java 订阅