JAVA Spring 学习笔记

Bean 容器

为什么要使用Bean容器

因为希望减少new的操作，这样当我们的类名发生改变时，影响会降到最小

Bean相当于一个管家

原来需要我们自己new的对象现在统统通过Bean来创建

怎么使用Bean?

首先我们需要利用pom.xml来建立对于spring的依赖

关于pom.xml是Maven的知识

这里不做赘述

<!--    Spring 依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.22.RELEASE</version>
    </dependency>

创建了spring依赖之后

我们还需要创建一个xml文件，这个xml文件就是用来配置Bean容器的

<?xml version="1.0" encoding="UTF-8"?>
<!--该文件配置Maven中的Bean文件-->
<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
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        ">

这是xml的基本信息，对于后缀为context的命令现在可以暂时忽略，后续会再介绍

然后就是配置Bean

对于每一个实现类我们都要配置一个Bean来和他对应

例如

    <bean id="userDaoimpl"  class="com.demo.Dao.impl.UserDaoimpl"/>

这里的id是bean 的ID ，后续我们通过bean来创建对象，就是通过这个id来寻找对应的Bean的

class对应的就是具体的实现类，注意一定要是实现类，因为我们创建对象都是实体类对象，没有接口对象

这里bean还有其他参数

例如

scope  这个参数用来表示Bean创建的对象是否是单例对象

如果是单例对象，那么每个bean只能创建一个对象，其余的都是对这个对象的引用

换而言之

就是无论创建多少对象，这些对象有着相同的地址

如果不是单例对象，那么不同对象有着不同的地址

配置好了一个Bean

下面就是如何利用Bean来创建对象

ApplicationContext applicationContext =
              new ClassPathXmlApplicationContext("applicationContext.xml");
        
        UserDao userDao = (UserDaoimpl)applicationContext.getBean("userDaoimpl");
        userDao.setId("123");
        System.out.println(userDao.getId());

有几个需要注意的地方

首先是

ClassPathXmlApplicationContext("applicationContext.xml")里边的参数
这里参数就是我们配置Bean文件的xml文件

其次我们可以用接口来指向实现对象，这是JAVA的内容，这里不做赘述

但是要在接口中声明相应的方法

然后就是getBean("userDaoimpl")  里边的参数就是我们前边提到的bean的id

这样我们通过Bean来创建一个对象就成功了

在实际开发中，我们并不会只单一的创造一个类

实际上是类与类之间有很多依赖关系

例如在UserServiceimpl.java中我们需要用到UserDao对象

这个时候我们不需要在UserServiceimpl利用上述的代码来创建

我们可以在xml中配置UserServiceimpl时配置相应的依赖关系

    <bean id="userServiceimpl" class="com.demo.Sevice.impl.UserServiceimpl">
<!--    为了避免在Service中new Dao对象，需要配置Service和Dao的依赖关系-->
<!--     首先name是指UserServiceimpl中变量的名称   这里的name必须有set方法与之对应-->
<!--     propery表示配置当前bean属性-->
<!--     ref表示参照哪一个bean  相当于一个映射  ref = beanId-->
<!--     可以有多个property  存在多个依赖关系-->
<!--     ref是对类的映射，Value是常规数据类型的设置-->
         <property name="userDao" ref="userDaoimpl"/>

   </bean>

注意一点 ref中的变量是已经配置好的bean的id

然后在UserServiceimpl必须有setName的方法

这是通过set方法来进行配置UserDao对象

我们也可以通过构造器来配置

    <bean id="userServiceimpl" class="com.demo.Sevice.impl.UserServiceimpl">
<!--    为了避免在Service中new Dao对象，需要配置Service和Dao的依赖关系-->
<!--     首先name是指UserServiceimpl中变量的名称   这里的name必须有set方法与之对应-->
<!--     propery表示配置当前bean属性-->
<!--     ref表示参照哪一个bean  相当于一个映射  ref = beanId-->
<!--     可以有多个property  存在多个依赖关系-->
<!--     ref是对类的映射，Value是常规数据类型的设置-->
         <property name="userDao" ref="userDaoimpl"/>
<!--        <property name="name" value="haha"/>-->
<!--        构造方法注入  如果没有set方法 就不用使用ref依赖传值  那么可以通过构造器传值-->
<!--        第一行是通过形参名字传值-->
<!--        第二行是通过数据类型传值-->
<!--        第三行通过参数位置传参-->

<!--        <constructor-arg name="userDao" ref="userDaoimpl"/>-->
<!--        <constructor-arg type="java.lang.String" value="haha"/>-->
<!--        <constructor-arg index="1" value="haha"/>-->

   </bean>

 

当然为了简化开发

spring提供了自动依赖

    <bean id="userServiceimpl" class="com.demo.Sevice.impl.UserServiceimpl" autowire="byType"/>

通过byType来建立依赖  那么只需要有对应的类的bean
通过bYName来建立依赖  那么对应的类的Bean的id一定要和变量名相同
例如：UserServiceimpl有一个 private UserDao userDao  那么UserDao对应的实现类的id一定要为userDao

现在自己创建的类的Bean以及如何建立相互的依赖我们已经清楚了
下面介绍怎么创建别人写好的类bean
回到一开始我们说的xml文件中的context
实际上就是一个新的命名空间，为了防止命名重复问题（个人理解哈）
然后我们创建相应的Bean就可以了
以链接数据库为例

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

 然后和创建Dao对象一样

根据id来创建就可以了

当然我们也可以把property写在同一个文件中中 然后在xml中加载就可以了

<!--加载context命名空间-->
<!--    使用context命名加载propert配置文件-->
<!--    System   是否加载系统的properties
-->
    <context:property-placeholder location="classpath*:*.property" system-properties-mode="NEVER"/>
<!--    注意配置component-scan是在context中配置-->

到这里 关于bean的基础用法就说完了

下面会介绍纯注解开发

然后上边说的这一堆都没用了

 注解开发

可以在对应的类中配置Bean

具体方法如下：

利用@Component 来声明当前类为Bean

@Component("userDaoimpl")
//Reposity和component效果一样
//spring 对于不同的层提供了不同的方法
//@Repository
public class UserDaoimpl implements UserDao {
    private String id;
    private String password;
}

同时要在xml文件中配置相关的说明这是一个Bean

<context:component-scan base-package="com.demo.Dao.impl"/>

也就是这样

这样会自动装填Imp目录下所有的Component

如果在Component中没有说明当前类对应的名称

则利用getBean()方法创建对象时，参数为对应的类

spring提供了@Component的三个衍生注解

分别对应三个不用的层次

@Controller 用于表现层Bean定义

@Service    用于业务层Bean定义

@Repository 用于数据层Bean定义

 纯注解开发

通过Java类来代替xml文件

我们首先定义一个配置类

名字随便

我这里叫做springConfig

然后我们利用注解来说明这是一个配置类

@Configuration

@Configuration
@ComponentScan("com.demo")
public class SpringConfig {
}

@ComponentScan("com.demo")
这个相当于搜索com.demo下的所有Bean
如果要搜索多个
需要用{}圈起来即可

@Configuration
@ComponentScan({"com.demo"，“xxxxx”})
public class SpringConfig {
}

 

因为xml被取代了
所以我们不再通过xml来获得

ApplicationContext对象
而是通过

AnnotationConfigApplicationContext方法来获得
代码如下

        ApplicationContext applicationContext =
                new AnnotationConfigApplicationContext(SpringConfig.class);

//        ApplicationContext applicationContext =
//              new ClassPathXmlApplicationContext("applicationContext.xml");

        UserDao userDao = (UserDaoimpl)applicationContext.getBean("userDaoimpl");

如果运行时有

Failed to read candidate component class: file [ ]; nested exception is org.springframework.core.NestedIOException报错

那是因为spring版本太低无法与JDK相兼容导致的

所以要升高spring版本

利用注解完成自动依赖注入

在Service中需要用到Dao对象

刚开始我们是通过New来创建

后来通过xml文件来实现bean的依赖

现在取消了xml文件

我们通过注解来完成依赖

只需要通过@Autowired来完成依赖即可

    @Autowired
    //利用注释加入依赖 根据类型自动装填
    private UserDao userDao;

以上是利用类型自动装配

也可以通过名称来完成装配

　　@Autowired

　　//利用名称完成依赖  前提必须有Autowired

    @Qualifier("userDaoimpl")
    private UserDao userDao;

使用@Value 能够完成简单类型的注入

同样的我们可以把所有的数据放在property文件中

然后在我们的配置类里

利用注解加载property文件即可

例如：

@PropertySource("Jdbc.property")

利用注解管理第三方Bean
以数据库为例首先我们要建立一个Java类让这个类中的方法返回我们想要的类型

public class JdbcConfig {
    //首先我们定义一个方法来获得要管理的对象
    //然后我们通过@Bean来表示当前方法是的返回值是一个Bean
    @Bean
    public DataSource getDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://");
        dataSource.setUsername("root");
        dataSource.setPassword("");
        return dataSource;
    }
}

然后在我们的配置文件中导入这个类

@Configuration
@ComponentScan("com.demo")
@PropertySource("Jdbc.property")
@Import(JdbcConfig.class)
public class SpringConfig {
}

然后在Main函数中根据类名来通过Bean创建相应的对象就可以了

对于第三方Bean中如果有对其他类的依赖

那么@Bean方法会自动装入

Spring整合Mybatis

首先看一下项目目录

 

 

 因为以前所有的知识点都在一个模块里，而且目录比较混乱

所以对模块重构了一下

首先我们要在pom.xml文件中声明所需要的依赖

新增这两个依赖

    <!--    利用spring操作数据库依赖  -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.3.23</version>
    </dependency>
    <!--mybaties 与spring整合的依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.6</version>
    </dependency>

然后介绍一下各个类的作用

Domain是对应数据库的类实体，这个类不需要声明为Bean

package com.demo.Domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@AllArgsConstructor
@NoArgsConstructor
@Data
public class User {
    private int id;
    private String Password;
}

 

然后是config文件，里边是各种配置类

SpringConfig配置类

 

 

package com.demo.config;

import org.springframework.context.annotation.*;
//声明这是一个配置类
@Configuration
//扫描所有的Bean文件
@ComponentScan("com.demo")
//@PropertySource("Jdbc.property")

//引用其他的配置类，各个配置类分开
@Import({JdbcConfig.class, MybatisConfig.class})
public class SpringConfig {
}

JdbcConfig配置类

package com.demo.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;

//@Configuration
public class JdbcConfig {
    //首先我们定义一个方法来获得要管理的对象
    //然后我们通过@Bean来表示当前方法是的返回值是一个Bean
    @Bean
    public DataSource getDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/mp");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }
}

为什么要提供一个DataSource的Bean

因为利用Spring链接数据库是我们要创建一个SqlSeesionFactoy对象

原来是通过xml文件来配置相关的信息

现在我们直接通过DataSource就能创建SqlSeesionFactoy对象

package com.demo.config;

import com.demo.Dao.UserDao;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class MybatisConfig {
    //在spring中 如果想要动用第三方类形成的Bean
    //我们直接利用形参传入即可
    //因为spring会自动扫描所需的依赖
    //前提是已经把第三方类声明为bean类型
    //mybitas通过sqlSessionFactor来创建sqlsession对象
    //sqlSession是操作数据库的类
　　 //Spring提供了SqlSessionFactoryBean来简化这个过程
　　//我们只需要传入一个DataSource对象就可完成创建
　　//同时还要说明数据库查询方法对应的接口

    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setTypeAliases(User.class);
        sessionFactoryBean.setDataSource(dataSource);

        return sessionFactoryBean;
    }
　　//设置Mapper对应的类
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("com.demo.Dao");
        return mapperScannerConfigurer;

    }

}

Config各个类介绍完毕

然后Dao是我们实现数据库查询的接口

也是利用注解开发的

UserDao

package com.demo.Dao;

import com.demo.Domain.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Component;

import java.util.List;

@Mapper
public interface UserDao {
    @Select("select * from user")
    public List<User> getAll();
 }

@Mapper 也是把这个接口声明为一个Bean 同时也说明这是一个Mapper类

然后就是服务层Service

首先是接口

package com.demo.Service;

import com.demo.Dao.UserDao;
import com.demo.Domain.User;

import java.util.List;

public interface UserService {
    public List<User> getAll();
}

然后是实现类

@Service说明这也是一个Bean

@Autowired  自动装填

因为我们已经把UserDao声明为一个Bean了

package com.demo.Service.impl;

import com.demo.Dao.UserDao;
import com.demo.Domain.User;
import com.demo.Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;
    public List<User> getAll() {
        return userDao.getAll();
    }
}

最后是测试类

package com.testDemo;

import com.demo.Domain.User;
import com.demo.Service.UserService;
import com.demo.Service.impl.UserServiceImpl;
import com.demo.config.SpringConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.util.List;

public class Test {
    @org.junit.Test
    public void test(){
        ApplicationContext applicationContext =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = (UserService) applicationContext.getBean(UserServiceImpl.class);
        List<User> userList = userService.getAll();
        for(User user:userList){
            System.out.println(user.getId()+" "+user.getPassword());
        }
    }
}