标签：name spring 06day org import com public

06day

spring

1.对比以往项目，Spring优势有哪些:方便解耦,简化开发;AOP切面级
程;声明式事务;整合各种优秀的框架，
2.发明者:Rod Johnson(罗宾·约翰逊)--Java世界的传奇大师，神级人
物;Spring FrameWork的缔造者;旷世奇书"葵花宝典"《Expert one on
one J2EE Design and Development》作者:Servlet2.4和JDO2.0的规
范专家;Java Development Community杰出人物。
3.不重复造轮子
4.使用Spring所需jar包
5.Spring官网:去spring官网找:https://spring.io/

核心在core Container（核心组件）

Data Access：对数据库访问层进行了封装

web：springmvc

spring IOC/DI(IOC和DI是同一个时间的两个名字)

注：不能构建控制层的对象

loC(lnversion of Control)中文名称:控制反转，也被称为Dl(dependency injection ):依赖注入。注意:属于同一件事情的两个名称。

创建对象的权利,或者是控制的位置,由JAVA代码转移到spring容器,由spring的容器控制对象的创建,就是控制反转。

由于控制反转概念比较含糊，所以在 2004 年大师级人物Martin Fowler又给出了一个新
的名字:“依赖注入”，相对loC而言，“依赖注入”明确描述了“被注入对象依赖loC容器来配置依赖对象”，DI(英文全称为DependencyInjection，中文译名为依赖注入)是loC的别名。

前后端通信中的java服务器分层结构

控制层（例子：BookController）：获取前端的数据，进行页面的跳转，调用业务层

业务层（例子：BookService）：处理业务（完成对于数据库的增删改查的上层语言调用的构建），代用数据库连接层

数据库连接层（例子：BooMapper）：跟数据库进行交互（增删改查）

注：可以间的理解为一个一个类

注：为了让类的命名规则有一定的规范这里每一层又分为（接口和实现类）

具体统一命名规则是用接口等于类的多态形式

而在spring框架中利用接口创建对象的逻辑则使用spring进行管理的

在程序中不手动创建对象了，则在程序中添加配置文件让框架进行创建

pwnda：框架自动实现的功能其中参数的传递都是用xml的配置文件完成的

IOC/DI的原理

首先框架会根据xml中传入的参数进行对象的创建，然后将创建的对象传入到spring容器当中，再有spring的容器出给java程序

spring的容器本质是一个map集合（stl的容器那种）。

（spring）属性的注入方式

以前的setter对应属性注入的设值注入

以前构造器方式对应属性注入的构造注入

属性注入- 设值注入

<bean id="b" class="com.msb.pojo.Book">
<property name="id" value="1"></property>
<property name="name" value="项目驱动零起点学Java"></propqrty>
</bean>

其中的name=id至于get，set方法有关系，与变量的名字没有关系

属性注入-构造注入

<beanid="b" class="com.msb.pojo.Book">
<constructor-arg name="id" value="1"></constructor-arg>
<constructor-arg name="name" value="项目驱动零起点学Java"></constructor-arg>
</bean>

实例代码：

package com.day03.test1;

import com.day03.pojo.Book;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
//创建spring的容器
//        创建容器之后框架的底层就已经创建对象了并且已经方法spring的容器里面了
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//    获取具体的对象
        Book book = (Book)context.getBean("b");
        System.out.println(book.getName());
        Book book1 = (Book)context.getBean("b1");
        System.out.println(book1.getName());

    }
}

<?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
         https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--    其中id就是对象的名字-->
<!--    <bean id="b" class="com.day03.pojo.Book">-->
<!--        <property name="id1" value="1"></property>-->
<!--        <property name="name1" value="觅长生"></property>-->
<!--    </bean>-->
    <bean id="b1" class="com.day03.pojo.Book">
<!--        构造器保证有带参数的构造函数-->
<!--        方法的名字与传入的形参有关系与变量名字无关-->
        <constructor-arg name="id" value="2"></constructor-arg>
        <constructor-arg name="name" value="活着"></constructor-arg>
    </bean>
    <bean id="girl" class="com.day03.pojo.Girl">
        <constructor-arg name="age" value="25"></constructor-arg>
        <constructor-arg name="name" value="未知"></constructor-arg>

    </bean>
    <bean id="boy" class="com.day03.pojo.Boy">
        <constructor-arg name="age" value="24"></constructor-arg>
        <constructor-arg name="name" value="小宇"></constructor-arg>
        <constructor-arg name="girlfriend" ref="girl"></constructor-arg>
    </bean>

</beans>

注入属性为引用类型

设置属性的值:
方式1:value:简单数据类型(基本数据类型+String)直接设置:
方式2:ref:需要引用另一个bean的id。也就是说这个参数是一个类类型，且这个
类的对象也被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
         https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--    其中id就是对象的名字-->
<!--    <bean id="b" class="com.day03.pojo.Book">-->
<!--        <property name="id1" value="1"></property>-->
<!--        <property name="name1" value="觅长生"></property>-->
<!--    </bean>-->
    <bean id="b1" class="com.day03.pojo.Book">
<!--        构造器保证有带参数的构造函数-->
<!--        方法的名字与传入的形参有关系与变量名字无关-->
        <constructor-arg name="id" value="2"></constructor-arg>
        <constructor-arg name="name" value="活着"></constructor-arg>
    </bean>
    <bean id="girl" class="com.day03.pojo.Girl">
        <constructor-arg name="age" value="25"></constructor-arg>
        <constructor-arg name="name" value="未知"></constructor-arg>

    </bean>
    <bean id="boy" class="com.day03.pojo.Boy">
        <constructor-arg name="age" value="24"></constructor-arg>
        <constructor-arg name="name" value="小宇"></constructor-arg>
        <constructor-arg name="girlfriend" ref="girl"></constructor-arg>
    </bean>

</beans>

package com.day03.pojo;

public class Boy {
    private int age;
    private String name;
    private Girl girlfriend;

    public Boy() {
    }

    public Boy(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public Boy(int age, String name, Girl girlfriend) {
        this.age = age;
        this.name = name;
        this.girlfriend = girlfriend;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Girl getGirlfriend() {
        return girlfriend;
    }

    public void setGirlfriend(Girl girlfriend) {
        this.girlfriend = girlfriend;
    }
}

package com.day03.pojo;

public class Girl {
    private int age;
    private String name;

    public Girl(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public Girl() {
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.day03.test1;

import com.day03.pojo.Boy;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Boy boy = (Boy)context.getBean("boy");
        System.out.println(boy.getName());
        System.out.println(boy.getGirlfriend().getName());
    }
}

注解

注解使用的目的

什么是注解?
注解其实就是代码里的特殊标记，这些标记可以在编译、类加载、运行时被读取，并执行相应的处理
通过使用注解，程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。代码分析工
具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。

注解的使用:
使用注解时要在其前面增加@符号，并把该注解当成一个修饰符使用。用于修饰它支持的程序元素
(包、类、构造器、方法、成员变量、参数、局部变量的声明)。

注解的重要性:
在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Arldroid中注
解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和
XML配置等。未来的开发模式都是基干注解的。一定程度上可以说:框架=注解+反射+设计模式。

IoC/DI相关的注解

其中前5个作用一样，用法也差不多

@Component的使用

在要创建对象的类中加入@Component注解，对象名字默认为:类名首字母变小写注解在哪个包下?要想找到这些注解，需要将注解所在的包进行扫描:设置需要扫描的包。并且需要在applicationContext.xml中添加context命名空间

前五个注解作用一样，只所以搞出这么多，就是在语义上给你区别，放入不同层用不同的注解，但是作用
都是创建对象。

代码示例核心（核心配置文件）：

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
         https://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context
         https://www.springframework.org/schema/context/spring-context.xsd">


<!--这个语句就会会让框架扫描出所有的包(com.day03.pojo)中的注解-->
        <context:component-scan base-package="com.day03.pojo"></context:component-scan>
<!--    其中id就是对象的名字-->
<!--    <bean id="b" class="com.day03.pojo.Book">-->
<!--        <property name="id1" value="1"></property>-->
<!--        <property name="name1" value="觅长生"></property>-->
<!--    </bean>-->
<!--    <bean id="b1" class="com.day03.pojo.Book">-->
<!--        构造器保证有带参数的构造函数-->
<!--        方法的名字与传入的形参有关系与变量名字无关-->
<!--        <constructor-arg name="id" value="2"></constructor-arg>-->
<!--        <constructor-arg name="name" value="活着"></constructor-arg>-->
<!--    </bean>-->
<!--    <bean id="girl" class="com.day03.pojo.Girl">-->
<!--        <constructor-arg name="age" value="25"></constructor-arg>-->
<!--        <constructor-arg name="name" value="未知"></constructor-arg>-->

<!--    </bean>-->
<!--    <bean id="boy" class="com.day03.pojo.Boy">-->
<!--        <constructor-arg name="age" value="24"></constructor-arg>-->
<!--        <constructor-arg name="name" value="小宇"></constructor-arg>-->
<!--        <constructor-arg name="girlfriend" ref="girl"></constructor-arg>-->
<!--    </bean>-->

</beans>

类对象（标记）：

package com.day03.pojo;

import org.springframework.stereotype.Component;
//底层识别这个注解之后会帮我们构建boy这个类的具体的对象
//要让框架识别注解的话就要对注解所在的包进行扫描
@Component
//创建对象的对象名字默认为是类名字的首字母小写
public class Boy {
    private int age;
    private String name;
    private Girl girlfriend;

    public Boy() {
    }

    public Boy(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public Boy(int age, String name, Girl girlfriend) {
        this.age = age;
        this.name = name;

        this.girlfriend = girlfriend;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Girl getGirlfriend() {
        return girlfriend;
    }

    public void setGirlfriend(Girl girlfriend) {
        this.girlfriend = girlfriend;
    }
}

package com.day03.test1;

import com.day03.pojo.Boy;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Boy boy = (Boy)context.getBean("boy");
        System.out.println(boy.getName());
        System.out.println(boy.getGirlfriend());
    }
}

@Value的使用

给普通数据类型赋值的注解，普通数据类型包括:八种基本数据类型+String，也不需要set方法

@Autowired的使用

添加@Autowired注解后会把容器中的对象自动注入进来，并且不需要依赖set方法.

会自动注入，默认是byType（根据类型注入），如果是多个同类型的bean，则使用byName

pwnda：根据注释生成的对象，怎么生成多个不同的对象

Web项目

Java（jar）项当和web（war）项目的区别

Java项目是由main()方法来开始的，直接依赖JVM就能被编译执行。Java项目不需要服务器

Web项目中的Java文件是tomcat服务器来触发的，脱离了web服务器就无法启动。Web项目需要服务
器。Web项目部署到服务器上，任何用户都可以通过浏览器来访问。将本地资源共亨给外部访问。

使用服务器

tomcat服务器对Servlet，Jsp，JNDl，JavaMail有很好的的支持，并目这个Web容器是开源免费的
(Apache 开源免费)

通过Maven构建项目

1.Maven构建项目类型:
Java项目-->jar项目
Web项目-->war项目
2.创建Maven-war项目步骤:
(1)创建Maven项目，添加webapp模板
先勾选create from archetype前面的复选框。
然后选择org.apache.maven.archetypes:maven-archetype-webapp
新建项目的剩余步骤都点击Next按钮即可，和不使用原型时创建Maven项目类似。
(2)注意pom.xml中是war项目
(3)观察目录结构与jar项目不同之处
(4)设置java目录为资源目录
(5)添加tomcat

（6）将项目添加到tomcat中

（7）运行

pwnda：每个模块都可以对应一个不同的项目

pwnda：导入tomcat服务器的两种方式：1、配置本地的Tomcat服务器。2、用maven的tomcat插件

SpringMVC（web项目）

可以实现控制层的对象的创建

springMVC的原因：可以获取前端传过来的而数据，也可以响应内容到前端

SpringMVC环境搭建

1.创建maven-web项日
2.补全目录
3.添加依赖
4.加入tomcat插件

5.创建控制器类，跳转到index.jsp

注：web文件的入口为：webapp/WEB_INF/web.xml

获取普通参数

获取普通参数，只需要在控制单元中提供与请求参数同名的方法参数即可，Spring MVC会自动进行类型转换。

使用类对象作为控制单元参数

一个包含私有属性，getter/setter方法和无参构造方法的Java类。是不是感觉
JavaBean:
和实体类特别像。其实写法上和实体类相同。唯一区别是实体类是数据库层面的概念，类型中属性要和数据库字段对应。而JavaBean的属性是灵活的，不是必须和哪里对应的。JavaBean是一个专业概念，可以简单点理解:使用类对象做为控制单元参数，接收请求参数。如果不是特别较真，狭义上可以认为JavaBean就是项目中的实体类。

在控制单元中放置一个类型对象，对象名称没有要求，只需要保证请求参数名和类的属性名
相同就可以了。

其中传入参数的名字与类中的变量名字必须相同

SSM整合

1、删除多余的东西

2、补全目录

3、添加依赖和插件

【1】mybatis的依赖
【2】连接mysql的依赖
【3】log4j的依赖
【4】spring的核心依赖
【5】springjdbc依赖
【6】spring整合mybatis的依赖
【7】springwebmvc的依赖

4、处理spring整合mybatis部分：

pwnda：当初用mybatis实现的一些与数据库连接的方法经过spring的整合之后就都用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"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">


<!--数据库连接的方法都封装到类里面，然后让spring框架的底层去实现-->
    <!-- 【1】连接数据库，获取数据源，配置数据源，设置数据库连接的四个参数 -->
    <!-- 利用setter方法完成属性注入，四个参数名固定的，注意源码中虽然没有driverClassName属性，但是有
    driverClassName的setter方法-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
         <property name="url" value="jdbc:mysql://127.0.0.1:3306/book?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=Asia/Shanghai&amp;allowPublicKeyRetrieval=true"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/></bean>


<!--也是用spring的底层去实现-->
<!--    【2】获职SqlSessionFactory对象-->
    <!-- 以前SqlSessionFactory都是在测试代码中我们自己创建的，但是现在不用了，整合包中提供的对于
    5qlSessionFactory的封装。里面提供了MyBatis全局配置文件所有配置的属性-->
<!--    id确定的名字都是底层确定好的类的名字-->
    <bean id="factory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入数据源-->
<!--        就是上面封装的数据源信息-->
        <property name="dataSource" ref="dataSource"/>
        <!--给包下类起别名-->
<!--        利用bean的属性将其注入-->
        <property name="typeAliasesPackage" value = "com.day03.pojo"></property>
        </bean>



<!--    【3】扫描mapper文件-->
    <!--设置扫描哪个包，进行接口绑定-->
<!--    所有Mapper接口代理对象都能创建出来，可以直接从容器中获取出来。-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!--    <!-和SqlSessionFactory产生联系，以前接口绑定sqlSession.getMapper(BookMapper.class);-->
<!--    都是通过以前接口绑定sq1Session来调用mapper，所以这里一定要注入工厂啊-->
<!--    注意这里sqlSessionFactoryBeanName类型为String，所以用value把工厂名字写过来就行&ndash;&gt;-->
<!--        这里面的factory是上面工厂类的-->
<!--pwnda:这里十一层套一层的,先用类去实现数据库对象,再用数据库对象去注入到类中实现工厂(与数据库通信)
       再用生成的工厂类扔到下面的类中去实现映射文件(对数据库进行操作)-->
        <property name="sqlSessionFactoryBeanName" value="factory"></property>
<!--        其中ref是类-->
    <!--扫描的包 -->
    <property name="basePackage" value="com.day03.mapper"></property>
</bean>

<!--【4】扫描包下注解-->
<context:component-scan base-package="com.day03.service"></context:component-scan>

</beans>

整合springmvc

pwnda：就是配置springMVC然后调用service曾传入的数据库

代码展示：

mybatis层：

package com.day03.mapper;

import java.util.List;

public interface BookMapper {
    List selectAllBooks();
}

<?xml version="1.0" encoding="UTF-8"?>
<!--约束（命名）-->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.day03.mapper.BookMapper">
    <select id="selectAllBooks" resultType="book">
        SELECT * FROM t_book;
    </select>
</mapper>

service：

package com.day03.service;

import java.util.List;

public interface BookService {
    List findAll();
}

package com.day03.service.impl;

import com.day03.mapper.BookMapper;
import com.day03.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookMapper bookMapper;
    public List findAll() {

//        从这里面调用数据库连接层,与其传递信息
        return bookMapper.selectAllBooks();
    }
}

controller：

package com.day03.controller;

import com.day03.pojo.Book;
import com.day03.service.BookService;
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 java.util.List;

@Controller
public class BookerController {
    @Autowired
    private BookService bookService;
    @RequestMapping("/testbook")
//    具体的定义返回的数据
    @ResponseBody
    public String findAll(){
        List list = bookService.findAll();
//        定义一个字符串用来接收响应的字符串
        String books = "";
        for (int i = 0;i<list.size();i++){
            Book book = (Book)list.get(i);
            books = books + book.getName();
            books = books + book.getAuthor();
        }
//        System.out.println("一共有基本书:" + list.size());
        return books;
    }

}

spring mvc配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
         https://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context
         https://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/mvc
         https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--    扫描控制器类，千万不要把service等扫描进来，也千万不要在Spring配置文件扫描控制器类所在包-->
    <context:component-scan base-package="com.day03.controller"></context:component-scan>
    <!--    SprinlMVc的注解生效:@RequestMapping-->
    <mvc:annotation-driven></mvc:annotation-driven>
</beans>

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"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">


<!--数据库连接的方法都封装到类里面，然后让spring框架的底层去实现-->
    <!-- 【1】连接数据库，获取数据源，配置数据源，设置数据库连接的四个参数 -->
    <!-- 利用setter方法完成属性注入，四个参数名固定的，注意源码中虽然没有driverClassName属性，但是有
    driverClassName的setter方法-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
         <property name="url" value="jdbc:mysql://127.0.0.1:3306/book?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=Asia/Shanghai&amp;allowPublicKeyRetrieval=true"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/></bean>


<!--也是用spring的底层去实现-->
<!--    【2】获职SqlSessionFactory对象-->
    <!-- 以前SqlSessionFactory都是在测试代码中我们自己创建的，但是现在不用了，整合包中提供的对于
    5qlSessionFactory的封装。里面提供了MyBatis全局配置文件所有配置的属性-->
<!--    id确定的名字都是底层确定好的类的名字-->
    <bean id="factory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入数据源-->
<!--        就是上面封装的数据源信息-->
        <property name="dataSource" ref="dataSource"/>
        <!--给包下类起别名-->
<!--        利用bean的属性将其注入-->
        <property name="typeAliasesPackage" value = "com.day03.pojo"></property>
        </bean>



<!--    【3】扫描mapper文件-->
    <!--设置扫描哪个包，进行接口绑定-->
<!--    所有Mapper接口代理对象都能创建出来，可以直接从容器中获取出来。-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!--    <!-和SqlSessionFactory产生联系，以前接口绑定sqlSession.getMapper(BookMapper.class);-->
<!--    都是通过以前接口绑定sq1Session来调用mapper，所以这里一定要注入工厂啊-->
<!--    注意这里sqlSessionFactoryBeanName类型为String，所以用value把工厂名字写过来就行&ndash;&gt;-->
<!--        这里面的factory是上面工厂类的-->
<!--pwnda:这里十一层套一层的,先用类去实现数据库对象,再用数据库对象去注入到类中实现工厂(与数据库通信)
       再用生成的工厂类扔到下面的类中去实现映射文件(对数据库进行操作)-->
        <property name="sqlSessionFactoryBeanName" value="factory"></property>
<!--        其中ref是类-->
    <!--扫描的包 -->
<!--        这个是basePack底层函数,其中其中的参数是接口BookMapper和其对应的配置文件-->
    <property name="basePackage" value="com.day03.mapper"></property>
</bean>

<!--【4】扫描包下注解-->
<context:component-scan base-package="com.day03.service"></context:component-scan>

</beans>

Springboot

Spring Boot是Spring公司的一个顶级项目，和Spring Framework是个级别的。

Spring Boot实际上是利用Spring Framework4 自动配置特性完成。编写项目时不需要编写
xml文件。发展到现在，Spring Boot已经具有很很大的生态圈，各种主流技术已经都提供了
Spring Boot的启动器。

核心思想：约定大于配置

为什么使用springboot（boot启动）：因为在spring中我们要写大量的xml配置文件，并且要自己导入一些依赖和插件。而springboot就是一个零配置的简化版的spring

pwnda：使用ssm是为了简化一些类和对象以及前端交互的步骤，而使用springboot是在ssm（不只是ssm）的基础上进一步封装将xml的功能封装成框架自动实现的

Springboot项目的搭建

案例：springboot整合springMVC的工程

(1)创建maven工程
(2)选择springboot的版本
启动器：正常导入springMVC包用spring-web-mvc而在springboot中使用的是spring-boot-starter-web其中的spring-boot-starter叫启动器

什么是启动器

Spring框架在项目中作用是Spring整合各种其他技术，让其他技术使用更加方便。Spring Boot的启
动器实际上就是一个依赖。这个依赖中包含了整个这个技术的相关jar包，还包含了这个技术的自动配
置，以前绝大多数XML配置都不需要配置了。以后每次使用Spring Boot整合其他技术时首先需要考
虑导入启动器。

代码：

<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.day03</groupId>
  <artifactId>TestSpringBoot</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>TestSpringBoot</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.7.6</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>


  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

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

  </dependencies>
</project>

什么是启动类

Spring Boot的启动类的作用是启动Spring Boot项目，是基于Main方法来运行的（是整个项目的入口）。并且启动类运行的时候会对同包或子包下的注解进行一个扫描（一般放到与持久层、service，contoller一个目录下）

代码：

package com.day03;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

//加上注解框架才能识别这是一个启动类
@SpringBootApplication
public class TestSpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(TestSpringBootApplication.class,args);

    }
}

启动类与启动器区别

启动类表示项目的启动入口
启动器表示jar包的坐标

springboot内置了tomcat

server.port=8888（端口配置）
server.servlet.context-path=/springboot01（上下文配置）

YML配置文件的介绍

springboot官方推荐的配置文件是yml文件，yml是用层级表示关系的一种配置文件。yml中没有标签，而是通过两个空格的缩进来表示层级结构。

properties中 :
serverport=8080
yml中:
server:
port: 8080
层级结构怎么找(SpringBoot常见配置，查看官网文档)
https://docs.spring.io/spring-boot/docs/2.7.6/reference/html/application
properties.html#appendix.application-properties
注意:文件名字为:application.yml，文件名字application开头，不能随意动。
注意冒号后空格。

SpringBoot整合SSM

导入依赖

代码：

<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.day03</groupId>
  <artifactId>TestSpringBoot</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>TestSpringBoot</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.7.6</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>

    </dependencies>
  </dependencyManagement>


  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

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

    <dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>2.1.3</version>
    </dependency>

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

  </dependencies>
</project>

编写配置文件

server:
  port: 9898
  servlet:
    context-path: /123
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/book?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
    password: root
    username: root

3.编写实体类，配置文件中加入别名
mybatis:
type-aliases-package: com.msb.pojo

4.定义mapper接囗
5.定义mapper.xml映射文件
在resource下新建mybatis文件夹
，mapper.xml文件名没有要求了，
不需要和接口名完全对
应了，是根据namespace去找接口。但是最好还是和接口名字保持一致
配置文件中加入映射文件位置:
6.
mybatis:
mapper-locations: classpath:mybatis/*.xml
7.定义启动类，在启动类加入mapper的包扫描
@springBootApplication
@MapperScan("com.msb.mapper")
public class MyApplication {
public static void main(Stringll args) {
SpringApplication.run(MyApplication.class,args);

代码：

mepper层：

package com.day03.mapper;

import com.day03.pojo.Book;

import java.util.List;

public interface BookMapper {

    List selectAllBooks();
}

<?xml version="1.0" encoding="UTF-8"?>
<!--约束（命名）-->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.day03.mapper.BookMapper">
    <select id="selectAllBooks" resultType="book">
        SELECT * FROM t_book;
    </select>
</mapper>

service：

package com.day03.service;

import java.util.List;



public interface BookService {
    List findAllBooks();
}

package com.day03.service.impl;

import com.day03.mapper.BookMapper;
import com.day03.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service

public class BookServiceImpl implements BookService {
    @Autowired
    private BookMapper bookMapper;
    @Override
    public List findAllBooks() {
        return bookMapper.selectAllBooks();
    }
}

contoller层：

package com.day03.controller;

import com.day03.pojo.Book;
import com.day03.service.BookService;
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 java.util.List;

@Controller
public class BookController {
    @Autowired
    private BookService bookService;

    @ResponseBody
    @RequestMapping("/test01")
    public String findBooks(){
        String books = "";
        List allBooks = bookService.findAllBooks();
        for(int i=0;i<bookService.findAllBooks().size();i++){
            Book book = (Book)bookService.findAllBooks().get(i);
            books += book.getAuthor()+book.getName();
        }
        return books;
    }
}

启动类：

package com.day03;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

//加上注解框架才能识别这是一个启动类
@SpringBootApplication
@MapperScan("com.day03.mapper")
public class TestSpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(TestSpringBootApplication.class,args);

    }
}

application.yml

<?xml version="1.0" encoding="UTF-8"?>
<!--约束（命名）-->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.day03.mapper.BookMapper">
    <select id="selectAllBooks" resultType="book">
        SELECT * FROM t_book;
    </select>
</mapper>

标签：name,spring,06day,org,import,com,public
From： https://www.cnblogs.com/pwnda/p/18591405

06day

06day

spring

spring IOC/DI(IOC和DI是同一个时间的两个名字)

前后端通信中的java服务器分层结构

IOC/DI的原理

（spring）属性的注入方式

注入属性为引用类型

注解

IoC/DI相关的注解

@Component的使用

@Value的使用

@Autowired的使用

Web项目

Java（jar）项当和web（war）项目的区别

使用服务器

通过Maven构建项目

SpringMVC（web项目）

SpringMVC环境搭建

获取普通参数

使用类对象作为控制单元参数

SSM整合

1、删除多余的东西

2、补全目录

3、添加依赖和插件

4、处理spring整合mybatis部分：

整合springmvc

Springboot

Springboot项目的搭建

什么是启动器

什么是启动类

启动类与启动器区别

YML配置文件的介绍

SpringBoot整合SSM

相关文章

赞助商

阅读排行