SpringBoot

三、Spring的JavaConfig

3.1、Spring的版本

spring是一个社区

3.1.1、Spring1.X版本

     该版本是Spring的第一个版本，只支持XML文件配置，不能使用注解，使用起来是有点复杂的

3.1.2、Spring2.x版本

     该版本与JDK1.5发布的时间非常接近，JDK1.5支持注解（如：@Override），同时spring2.x也引入了注解的支持，这个时候spring就可以使用xml和注解

3.1.3、spring3.x/4.x版本

     引入java配置的方式，就是说使用java类替代xml文件。我们就可以完全脱离xml文件，避免看了开发人员在Java类与xml文件之间的频繁切换问题。而且SpringBoot推荐我们使用Java配置的方式来配置Spring

    现在Spring已经发展到了5.x版本。

3.2、JavaConfig

3.2.1、概述

     使用Java类替代原来的xml文件，主要使用      @Configuration注解

3.2.2、案例一

    需求：使用Java配置的方式创建对象

1. 在pom文件中引入依赖
2. 创建dao层
3. 创建service层
4. 创建测试类
5. 创建Java配置类

第一步：创建项目

第二步：在pom文件中引入依赖

pom.xml:引入依赖

<?xml version="1.0" encoding="UTF-8"?>
<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>com.zhiyou</groupId>
    <artifactId>day3_21_javaconfig</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <slf4j.version>1.7.7</slf4j.version>
        <log4j.version>1.2.17</log4j.version>
        <spring.version>4.3.7.RELEASE</spring.version>
    </properties>
    <dependencies>
        <!-- Spring依赖 -->
        <!-- 1.Spring核心依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- 2.Spring dao依赖 -->
        <!-- spring-jdbc包括了一些如jdbcTemplate的工具类 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- 3.Spring web依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--springMVC依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- 日志文件管理包 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
    </dependencies>

</project>

第三步：创建实体类

package pojo;

public class User {
    private  String name;
    private String  pass;

//getter和setter方法
//构造方法
//toString方法

}

第三步：创建dao层

package dao;

import pojo.User;

import java.util.ArrayList;
import java.util.List;

public class UserDao {

    //获取所有数据
    public List<User> queryAll(){
        List<User> users=new ArrayList<User>();
    
  //模拟连接数据库   （使用集合当做数据库）
        for (int i=0;i<10;i++){
            // 向集合中添加数据
            users.add(new User("name"+i,"pass"+i));
        }
        return users;
    }


}

第五步：写service层

package service;

import dao.UserDao;
import pojo.User;

import javax.annotation.Resource;
import java.util.List;

public class UserService {

    @Resource
    private UserDao ud;

    public List<User> queryAll(){
        return ud.queryAll();
    }


}

第六步：创建java测试类

注：
  @Configuration：  使用java类替代原先的XML文件。声明该类是一个配置类（如：可以在该类直接创建对象，不需要再去配置文件创建对象了）
  @Bean： 创建对象。 使用的是方法创建对象，方法名就是它在ioc中的标记，用的时候去ioc容器中给它取出来即可（getbean方法）

package conf;

import dao.UserDao;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import service.UserService;

/**
 *  该类的作用：使用java类替代原先的XML文件，（可以在该类直接创建对象，不需要再去配置文件创建对象了）
 *  实现方式：使用@Configuration注解        该注解是用来说明该类是一个配置类。
 *
 */
@Configuration
public class JavaConf {
    /**
     *   创建对象：使用@Bean注解
     *           使用的是方法来创建对象，方法的返回值是对象的类型，
     *           方法名就是对象在IOC容器中的name，相当于bean标签的name属性
     *  return对象即可
     */

    //service和dao层，一共是创建了2个对象
   @Bean
    public UserDao userDao(){
        return new UserDao();
    }

    @Bean
    public UserService userService(){
        return new UserService();
    }


}

第七步：创建测试类

package test;

import conf.JavaConf;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import pojo.User;
import service.UserService;

import java.util.List;

public class UserTest {
    public static void main(String[] args){
        //1.获取Java配置类
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(JavaConf.class);
        //2.获取IOC容器中的对象
        UserService us = (UserService) context.getBean("userService");//返回值是对象Object---强转为UserService类型
      
        //3.调用方法
        List<User> users = us.queryAll();
        for (User user:users) {
            System.out.println(user);
        }

    }

}

       查看结果：

3.2.3、案例二

         需求：在案例一的基础上读取外部文件

1）创建db.properties文件

2）读取

3）测试

4）总结

 

第一步：创建db.properties文件

        创建位置是;main-resources下，而不是main-java下

mysql_driver=com.mysql.jdbc.Driver
mysql_url=jdbc:mysql:///ssm  
mysql_user=root
mysql_pass=123

同时可以看见这里连接的数据库是jdbc（所以下边的创建对象是jdbc的写法，也可以使用成c3p0等）

第二步：读取外部文件

 1）  注：需要连接数据库，需要在pom.xml中引入mysql的依赖

      <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

2）去写配置类JavaConfig

注:

  @PropertySource: 读取外部文件，可以读取多个
 ignoreResourceNotFound：文件找不到是否继续执行，默认值是false，改成true生效

例：

     @Value：给变量赋值

package conf;

import dao.UserDao;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import service.UserService;

/**
 *  该类的作用：使用java类替代原先的XML文件，（可以在该类直接创建对象，不需要再去配置文件创建对象了）
 *  实现方式：使用@Configuration注解        该注解是用来说明该类是一个配置类。
 *
 */
@Configuration  //声明该类是配置类
@PropertySource(value = {"classpath:db.properties","classpath:aaa"},ignoreResourceNotFound = true)//读取外部文件
public class JavaConf {
    /**
     *   创建对象：使用@Bean注解
     *           使用的是方法来创建对象，方法的返回值是对象的类型，
     *           方法名就是对象在IOC容器中的name，相当于bean标签的name属性
     *  return对象即可
     */

    //声明变量保存driver
     @Value("${mysql_driver}")
    private String driver_class;
    @Value("${mysql_url}")
     private String url;
    @Value("${mysql_name}")
    private String user;
    @Value("mysql_pass")
    private String pass;
    //配置数据源
    @Bean
    public DriverManagerDataSource dataSource(){
        DriverManagerDataSource dataSource=new DriverManagerDataSource();
        //设置driver
        dataSource.setDriverClassName(driver_class);
        //设置url
        dataSource.setUrl(url);
        //设置username
        dataSource.setUsername(user);
        //设置password
        dataSource.setPassword(pass);

        return  dataSource;
    }


    //service和dao层，一共是创建了2个对象
   @Bean
    public UserDao userDao(){
        return new UserDao();
    }

    @Bean
    public UserService userService(){
        return new UserService();
    }


}

第三步 测试

查看结果：

 

四、SpringBoot

4.0、Spring体系

    大家已经学会Spring和SpringMVC了，那么Spring有多少东西呢？

     去官网看：https://spring.io

4.1、Spring历史遗留问题

     我们在使用Spring和SpringMVC开发项目时虽然已经很方便了，但是我们还是需要写很多的配置文件，而且这些配置每次的文件都类似。     比如我们只想实现一个邮件收发的系统，在做之前就需要大量的配置。就是这些大量的配置使得初学者产生恐惧。Spring框架的开发者同样发现了这些问题。所以SpringBoot就横空出世。

4.2、SpringBoot介绍

     SpringBoot其实并不是一个全新的框架，而是内部集成了很多的其他框架，并且做好了默认的配置，比如spring与mybatis的整合，spring与springmvc的整合，spring与redis的整合等等。使得开发者可以非常方便的开发，部署项目。

4.3、SpringBoot的优势

1）开箱即用，提高开发效率和部署效率

2）内部集成了很多框架的默认配置

3）内部内嵌一个tomcat，无需依赖外部的web容器

4.4、入门案例

    使用工具：IDEA、Eclipse均可

    我使用的是：idea

4.4.0、IDEA与eclipse区别

IDEA就是一辆跑车，eclipse就是一辆拖拉机

Eclipse是基于工作空间的，创建项目时创建project

IDEA是基于Project，创建项目创建module，更方便分模块开发

4.4.1、设置IDEA使用的maven插件

一些普通设置

4.4.2、案例一：

   需求：在页面上显示helloworld

第一步：创建maven项目

第二步  配置pom文件

       导入springmvc的依赖

<?xml version="1.0" encoding="UTF-8"?>
<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>
	<!--继承的项目-->
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.3.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<!--本项目的信息-->
	
	<groupId>com.zhiyou</groupId>
	<artifactId>day3_21_springboot</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>day3_21_springboot</name>
	<description>Demo project for Spring Boot</description>
	<!--定义版本-->
	<properties>
		<!--JDK版本-->
		<java.version>1.8</java.version>
	</properties>
	<!--相关依赖-->
	<dependencies>
		<!--springboot相关依赖-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>
		<!--springboot测试依赖-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<!--springmvc依赖-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<!--配置maven插件-->
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

 

第三步 直接创建Controller写方法即可

package com.zhiyou.day3_21_springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

//这个类是主类
@SpringBootApplication
@Controller
public class Day321SpringbootApplication {

	public static void main(String[] args) {

		SpringApplication.run(Day321SpringbootApplication.class, args);
	}

	@RequestMapping("hello.do")
	@ResponseBody
	public String hello(){
		return "hello";
	}

}

查看结果：

可以看见中页面中显示hello内容了

4.5、接收参数

4.5.1、接收单个参数

第一步：写实体类

第二步：写控制层

    @RestController    该注解是一个组合注解，是Controller和ResponseBody的组合

package com.zhiyou100.controller;

import org.springframework.web.bind.annotation.RestController;
/*@Controller
@ResponseBody*/
@RestController   //该注解是一个组合注解，是Controller和ResponseBody的组合
public class TestController {

    //接收一个参数
    public String getAlone(Integer id){
        return "id=="+id;
    }

}

第三步：在主类中开启包扫描

查看：

4.5.2、接收一个对象

package com.zhiyou100.controller;

import com.zhiyou100.pojo.Goods;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/*@Controller
@ResponseBody*/
@RestController   //该注解是一个组合注解，是Controller和ResponseBody的组合
public class TestController {

    //接收一个参数
    @RequestMapping("get1.do")
    public String getAlone(Integer id){
        return "id=="+id;
    }

    //接受一个对象
    @RequestMapping("get2.do")
    public  String getObject(Goods goods){
        return "goods===="+goods;
    }
}

同时参考上一个接收一个参数的操作

结果：

4.6、响应

4.6.1、请求转发

使用forward

    需求：请求转发到action

创建页面：

写控制层

package com.zhiyou100.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller  //注意：这是要跳转页面，可就不能使用@RestController了
public class TestController2 {
   
    @RequestMapping("method1.do")
    public String method1(ModelAndView model){
        //设置要返回的页面(请求转发到页面)
        //model.setViewName("hello.html");  //这样写的话，有参数，有返回值,返回值为ModelAndView
        //return model;

        return "hello.html";   //这样写的话，不需要参数，返回值类型为String 
    }
 
//请求转发到方法
    @RequestMapping("method2.do")
    public String method2(){
        //默认是请求转发，但是如果要转发到另一个action中,则需要使用forward指明
        return "forward:method1.do";
    }




}

 

结果：

4.6.2、重定向

使用redirect

package com.zhiyou100.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller  //注意：这是要跳转页面，可就不能使用@RestController了
public class TestController2 {
    //重定向到页面
    @RequestMapping("method3.do")
    public String method3(){
        return "redirect:http://www.zhiyou100.com";
    }

     //重定向到方法
    @RequestMapping("method4.do")
    public  String method4(){
        return "redirect:method3.do";
    }

}

结果：

4.7、SpringBoot静态资源

4.7.1、位置

  SpringBooot的静态资源都存放到resources下的static、public包下比如图片，js，html，css

4.7.2、访问静态资源

在resources下创建public目录存放一张图片访问，在浏览器上输入http://localhost:8080/3.jpg，如果能访问到说明成功。

 

五、SpringBoot细节

5.1、主类

      @SpringBootApplication：该注解是一个组合注解（主类中的注解），有@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan、@Filter等

    @SpringBootConfiguration：是一个组合注解，由@Configuration等，说明该注解所描述的类是一个xml文件。

   @EnableAutoConfiguration：使用自动配置，就是说使用springboot框架自动继承其他框架的配置。 如果不想用默认的配置使用excludeName属性或者exclude属性。

   @ComponentScan：设置扫描包，默认扫描同包和子包

    @Filter：定义过滤器

5.2、实现原理

   SpringBoot的实现是由启动器和自动配置以及大量的注解。

5.3、自动配置

   SpringBoot不是一个全新框架，而是其中内部继承其他的框架并做了一些默认配置，这就是自动配置。

5.4、启动器

    启动器是我们在pom文件中引入的依赖，比如spring-boot-starter-web，引入之后，maven就会自动去加载相关的jar包依赖。Springboot就认为我们需要使用到这些技术。就会自动加载默认的配置。

常用的启动器有哪些？

spring-boot-starter-web：开发web网站内部集成springmvc和tomcat等

spring-boot-starter-jdbc：连接数据库

spring-boot-starter-thymeleaf：模板引擎，用来显示数据。

spring-boot-starter-mysql：集成mysql

六 任务

6.1、掌握JavaConfig

6.2、掌握SpringBoot基本配置和常用的注解，所有的配置都要清楚

6.3、熟练使用SpringBoot接收请求做出响应，访问静态资源

6.4、理解SpringBoot的原理

6.5、使用JavaConfig连接mysql数据库完成一个查询操作在页面上显示。（提示：可以使用Spring自带的数据库访问技术也可以使mybatis都行）