spring自学笔记(二)

最新推荐文章于 2023-10-10 21:11:26 发布

stu_kk

最新推荐文章于 2023-10-10 21:11:26 发布

阅读量238

点赞数 1

分类专栏： Java开发文章标签： spring java 前端

本文链接：https://blog.csdn.net/m0_54409739/article/details/125782487

版权

Java开发专栏收录该内容

42 篇文章 1 订阅

订阅专栏

1、核心容器

1.1、容器的创建方式

在之前我们容器的主要创建方式还是这样子的：

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

这个“ ”中写的就是配置文件的名称

然后，还有一种方法就是：

ApplicationContext ctx = new FileSystemXmlApplicationContext("E:\\workplace\applicationContext.xml");

这个“ ”中写的就是配置文件的完整路径。这种方式虽能实现，但是当项目的位置发生变化后,代码也需要跟着改,耦合度较高,不推荐使用。

1.2、bean的三种获取方式

第一种：就是前面使用的方式，这种方式存在的问题是每次获取的时候都需要进行类型转换，有没有更简单的方式呢?

UserService userService = (UserService)context.getBean("userService");

第二种：直接在逗号后定义好类

UserService userService = context.getBean("userService",UserService.class);

第三种：直接按照类去找，前提是必须要确保IOC容器中该类型对应的bean对象只能有一个。

UserService userService = context.getBean(UserService.class);

2、IOC/DI注解开发

Spring的IOC/DI对应的配置开发就已经讲解完成，但是使用起来相对来说还是比较复杂的，复杂的地方在配置文件，所以注解开发就来方便我们了。

2.1、注解开发之定义bean

首先，xml配置文件配置<bean>这么麻烦的东西肯定删除掉他，换成这个

<!--    <bean name="userDao" class="stukk.Dao.Impl.UserDaoImpl"/>-->

<?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
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">

<context:component-scan base-package="stukk"/>

</beans>

接着，实现类上添加@Component注解就可以了！

package stukk.Dao.Impl;

import org.springframework.stereotype.Component;
import stukk.Dao.UserDao;
@Component("userDao")
public class UserDaoImpl implements UserDao {
    public void deleteById(int id) {
        System.out.println("删除第"+id+"个数据");
    }
}

package stukk;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import stukk.Dao.UserDao;

public class App{
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = context.getBean("userDao",UserDao.class);
        userDao.deleteById(12);
    }
}

正常运行！

2.2、纯注解开发

上面已经可以使用注解来配置bean,但是依然有用到配置文件，在配置文件中对包进行了扫描，Spring在3.0版已经支持纯注解开发

Spring3.0开启了纯注解开发模式，使用Java类替代配置文件，开启了Spring快速开发赛道

首次把xml配置文件给他嘎了。

接着创建一个配置类

在配置类上添加包扫描注解@ComponentScan替换<context:component-scan base-package=""/>

package stukk.Dao.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("stukk")
public class springConfig {
}

运行类：

package stukk;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import stukk.Dao.UserDao;
import stukk.Dao.config.springConfig;

public class App{
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(springConfig.class);
        UserDao userDao = context.getBean("userDao",UserDao.class);
        userDao.deleteById(12);
    }
}

1：@Configuration

名称	@Configuration
类型	类注解
位置	类定义上方
作用	设置该类为spring配置类
属性	value（默认）：定义bean的id

2：@ComponentScan

名称	@ComponentScan
类型	类注解
位置	类定义上方
作用	设置spring配置类扫描路径，用于加载使用注解格式定义的bean
属性	value（默认）：扫描路径，此路径可以逐层向下扫描

3：@Scope

名称	@Scope
类型	类注解
位置	类定义上方
作用	设置该类创建对象的作用范围可用于设置创建出的bean是否为单例对象
属性	value（默认）：定义bean作用范围， ==默认值singleton（单例），可选值prototype（非单例）==

2.3、纯注解开发模式下的bean周期

在BookDaoImpl中添加两个方法，init和destroy,方法名可以任意。

怎么判断哪个是初始化方法，哪个是销毁方法呢？其实只需要在对应的方法上添加@PostConstruct和@PreDestroy注解即可。

package stukk.Dao.Impl;

import org.springframework.stereotype.Component;
import stukk.Dao.UserDao;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component("userDao")
public class UserDaoImpl implements UserDao {
    public void deleteById(int id) {
        System.out.println("删除第"+id+"个数据");
    }
    @PostConstruct
    public void init(){
        System.out.println("init...init...init...");
    }
    @PreDestroy
    public void destory(){
        System.out.println("destory...destory...destory...");
    }
}

package stukk;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import stukk.Dao.UserDao;
import stukk.Dao.config.springConfig;

public class App{
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(springConfig.class);
        UserDao userDao = context.getBean("userDao",UserDao.class);
        userDao.deleteById(12);
        context.close();
    }
}

知识点1：@PostConstruct

名称	@PostConstruct
类型	方法注解
位置	方法上
作用	设置该方法为初始化方法
属性	无

知识点2：@PreDestroy

名称	@PreDestroy
类型	方法注解
位置	方法上
作用	设置该方法为销毁方法
属性	无

3、注解开发依赖注入

3.1、注解实现按照类型注入

在UserServiceImpl类的userDao属性上添加@Autowired注解

package stukk.Service.Impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Service;
import stukk.Dao.BookDao;
import stukk.Dao.Impl.UserDaoImpl;
import stukk.Dao.UserDao;
import stukk.Service.UserService;

@Service("userService")
public class UserServiceImpl implements UserService {
    @Autowired
    UserDao userDao;
    public void deleteById(int id) {
        userDao.deleteById(id);
    }
}

3.2、注解实现按照名称注入

当根据类型在容器中找到多个bean,注入参数的属性名又和容器中bean的名称不一致，这个时候该如何解决，就需要使用到@Qualifier来指定注入哪个名称的bean对象。

package stukk.Service.Impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Service;
import stukk.Dao.BookDao;
import stukk.Dao.Impl.UserDaoImpl;
import stukk.Dao.UserDao;
import stukk.Service.UserService;

@Service("userService")
public class UserServiceImpl implements UserService {
    @Autowired
    @Qualifier("userDao2")
    UserDao userDao;

    public void deleteById(int id) {
        userDao.deleteById(id);
    }
}

3.3、简单数据类型注入

利用@value就可以直接注入简单类型了

package stukk.Dao.Impl;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
import stukk.Dao.UserDao;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Repository("userDao1")
public class UserDaoImpl implements UserDao {
    @Value("stukk")
    private String name;
    public void deleteById(int id) {
        System.out.println(name+"删除第"+id+"个数据");
    }
}

注意数据格式要匹配，如将"abc"注入给int值，这样程序就会报错。现在我们会有一种感觉，就是这个注解好像没什么用，跟直接赋值是一个效果，还没有直接赋值简单，所以这个注解存在的意义是什么?其实@Value一般会被用在从properties配置文件中读取内容进行使用，比如：

1.先准备好properties文件

2.添加@PropertySource("")注解在实现类上

package stukk.Dao.Impl;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
import stukk.Dao.UserDao;


@Repository("userDao1")
@PropertySource("user.properties")
public class UserDaoImpl implements UserDao {
    @Value("${name}")
    private String name;
    public void deleteById(int id) {
        System.out.println(name+"删除第"+id+"个数据");
    }
}

注意:

如果读取的properties配置文件有多个，可以使用@PropertySource的属性来指定多个
```
@PropertySource({"jdbc.properties","xxx.properties"})
```
@PropertySource注解属性中不支持使用通配符*,运行会报错
```
@PropertySource({"*.properties"})
```
@PropertySource注解属性中可以把classpath:加上,代表从当前项目的根路径找文件
```
@PropertySource({"classpath:jdbc.properties"})
```

知识点1：@Autowired

名称	@Autowired
类型	属性注解或方法注解（了解）或方法形参注解（了解）
位置	属性定义上方或标准set方法上方或类set方法上方或方法形参前面
作用	为引用类型属性设置值
属性	required：true/false，定义该属性是否允许为null

知识点2：@Qualifier

名称	@Qualifier
类型	属性注解或方法注解（了解）
位置	属性定义上方或标准set方法上方或类set方法上方
作用	为引用类型属性指定注入的beanId
属性	value（默认）：设置注入的beanId

知识点3：@Value

名称	@Value
类型	属性注解或方法注解（了解）
位置	属性定义上方或标准set方法上方或类set方法上方
作用	为基本数据类型或字符串类型属性设置值
属性	value（默认）：要注入的属性值

知识点4：@PropertySource

名称	@PropertySource
类型	类注解
位置	类定义上方
作用	加载properties文件中的属性值
属性	value（默认）：设置加载的properties文件对应的文件名或文件名组成的数组

3、spring整合

好了，学了这么多spring的基础知识，还是得来整合一下我们需要的一些框架的。

3.1、spring整合Mybatis

1、先去建个数据库，创建个表先吧，在ssm_db数据库中创建表ball

create table ball
(
    id int primary key auto_increment,
    name varchar(110) not null,
    money double not null
);
insert into ball(name,money) values
('足球',65.5),
('橄榄球',78.9),
('篮球',56.5);

2、创建Maven项目，在pom文件中导入需要的配置

<?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>org.example</groupId>
    <artifactId>spring_mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9</version>
        </dependency>

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

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.19</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.7</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.4</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.19</version>
        </dependency>

    </dependencies>

</project>

3、写个实体类

package stukk.Pojo;

public class Ball {
    private Integer id;
    private String name;
    private Double money;

    @Override
    public String toString() {
        return "Ball{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }
}

4、在Dao数据层写好增删改查的方法：

package stukk.Dao;

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import stukk.Pojo.Ball;

public interface BallDao {
    //增
    @Insert("insert into ball(name,money) values(#{name},#{money})")
    void add(Ball ball);

    //删
    @Delete("delete from ball where id = #{id}")
    void delete(Integer id);

    //改
    @Update("update ball set name = #{name},money = #{money} where id = #{id}")
    void update(Integer id);

    //查
    @Select("select * from ball where id = #{id}")
    Ball selectById(Integer id);
}

5、在Service业务层

package stukk.Service;

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import stukk.Pojo.Ball;

public interface BallService {
    //增
    void add(Ball ball);

    //删
    void delete(Integer id);

    //改
    void update(Integer id);

    //查
    Ball selectById(Integer id);
}


package stukk.Service.Impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import stukk.Dao.BallDao;
import stukk.Pojo.Ball;
import stukk.Service.BallService;

@Service("ballService")
public class BallServiceImpl implements BallService {

    @Autowired
    BallDao ballDao;

    public void add(Ball ball) {
        ballDao.add(ball);
    }

    public void delete(Integer id) {
        ballDao.delete(id);
    }

    public void update(Integer id) {
        ballDao.update(id);
    }

    public Ball selectById(Integer id) {
        return ballDao.selectById(id);
    }
}

6、配置好jdbc的数据库中的信息

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/ssm_db?useSSL=false
username=root
password=root

7、在JdbcConfig配置类中配置好

package stukk.Config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class JdbcConfig {
    @Value("${username}")
    private String username;

    @Value("${password}")
    private String password;

    @Value("${url}")
    private String url;

    @Value("${driver}")
    private String driver;

    @Bean
    public DataSource getDataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUsername(username);
        ds.setPassword(password);
        ds.setUrl(url);
        return ds;
    }
}

7、MybatisConfig配置类

package stukk.Config;


import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class MybatisConfig {

    @Bean
    public SqlSessionFactoryBean getSqlSessionFactoryBean(DataSource dataSource){
        SqlSessionFactoryBean sql = new SqlSessionFactoryBean();
        //设置一下数据源
        sql.setDataSource(dataSource);
        return sql;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        //设置Dao层的路径
        mapperScannerConfigurer.setBasePackage("stukk.Dao");
        return mapperScannerConfigurer;
    }

}

8、主配置类

package stukk.Config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;

@Configuration
@ComponentScan("stukk")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class , MybatisConfig.class})
public class SpringConfig {
}

9、在App类中直接运行

package stukk;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import stukk.Config.SpringConfig;
import stukk.Pojo.Ball;
import stukk.Service.BallService;

import javax.swing.*;

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        BallService ballService = context.getBean(BallService.class);
        Ball ball = ballService.selectById(2);
        System.out.println(ball);
    }
}