Spring基础入门学习【持续更新】

文章目录

常用依赖

1.pring-context依赖3.junit4.数据库驱动5.druid数据池6.spring-test 1.Spring入门

1.Bean标签配置以及实例化2.Bean的依赖注入3.Spring配置druid 2.Spring注解开发

1.Spring原始注解2.Spring新注解`*` 3.Spring集成Junit

常用依赖 1.pring-context依赖


  org.springframework
  spring-context
  5.3.13

3.junit


  junit
  junit
  4.12
  test

4.数据库驱动


  mysql
  mysql-connector-java
  5.1.32

5.druid数据池


  com.alibaba
  druid
  1.1.10

6.spring-test


  org.springframework
  spring-test
  5.3.13

1.Spring入门 1.Bean标签配置以及实例化

1.基本配置:

Bean默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。
基本属性：
id：Bean实例在Spring容器中的唯一标识

class:Bean的全限定名称,即全包名，可通过复制被引用类的Reference

2.范围配置：

scope：指对象的作用范围，取值如下：

取值范围	说明
singleton	默认值，单例的
prototype	多例的
request	WEB项目中，Spring创建一个Bean的对象，将对象存入到request 域中
session	WEB项目中，Spring创建一个Bean的对象，将对象存入到session 域中
global session	WEB 项目中，应用在Portlet 环境，如果没有Portlet环境那么globalSession相当

2.1.当scope的取值为singleton时
Bean的实例化个数: 1个
Bean的实例化时机:当Spring核心文件被加载时,实例化配置的Bean实例
Bean的生命周期:
对象创建: 当应用加载，创建容器时，对象就被创建了
对象运行: 只要容器在，对象一直活着
对象销毁: 当应用卸载，销毁容器时,对象就被销毁了

2.2.当scope的取值为prototype时
Bean的实例化个数：多个
Bean的实例化时机：当调用getBean方法时实例化Bean
对象创建：当使用对象时，创建新的对象实例
对象运行：只要对象在使用中，就一直活着
对象销毁：当对象长时间不用时，被Java的垃圾回收器回收了

3.生命周期配置(不重要)

init-method：指定类中的初始化方法名称
destroy-method:指定类中销毁方法名称

4.Bean实例化三种方式
1.无参构造方法实例化重点

2.工厂静态方法实例化

因为是静态的，所以直接调用静态里面的方法

public class StaticFactory {
    public static UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

3.工厂实例方法实例化

动态的话，要先有工厂对象，再调用其方法

public class DynamicFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

2.Bean的依赖注入

依赖注入(Dependency Injection):它是Spring框架核心IOC的具体实现。
使用Spring来维护业务层和持久层的依赖关系。简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

1.注入方法

1.1构造方法

通过生成有参构造和无参构造

private UserDao userDao;
public UserServiceImpl(UserDao userDao) {
    this.userDao = userDao;
}
public UserServiceImpl() {
}

constructor-arg标签中的name值是通过有参构造器中的参数而来的

1.2set方法（用的多）

private UserDao userDao;
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}
public void save(){
    userDao.save();
}

property中的name值是setUserDao方法名中的userDao所来的

2.集合类型注入

3.引入其他配置文件

3.Spring配置druid

1.pom.xml中导入mysql-connector-java和druid依赖

2.resources文件夹下新建applicationContext.xml和jdbc.properties文件

3.jdbc.properties文件中配置数据库信息

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root

4.在applicationContext.xml文件中配置

5.测试类里面

public void test3() throws Exception{
    ApplicationContext app = new 		      ClassPathXmlApplicationContext("applicationContext.xml");
    DataSource dataSource = (DataSource) app.getBean("dataSource");
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
    connection.close();
}

2.Spring注解开发 1.Spring原始注解

Spring原始注解主要是替代Bean标签的配置

注解	说明
@Component	使用在类上用于实例化Bean
@Controller	使用在web层类上用于实例化Bean
@Service	使用在service层类上用于实例化Bean
@Repository	使用在dao层类上用于实例化Bean
@Autowired	使用在字段上用于根据类型依赖注入
@Qualifier	结合@Autowired一起使用用于根据名称进行依赖注入
@Resource	相当于@Autowired+@Qualifier,按照名称进行注入
@Value	注入普通属性
@Scope	标注Bean的作用范围
@PostConstruct	使用在方法上标注该方法是Bean的初始化方法
@PreDestroy	使用在方法上标注该方法是Bean的销毁方法

@Component("userService")

@Autowired  
@Qualifier("userDao")

注意：在applicationContext.xml``中，要配置组件扫描

当通过注解方式时，set方法可以不写

当通过xml方式时，set方法要写

普通类型注解：

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

但在applicationContext.xml文件中，要加载外部的properties文件:

2.Spring新注解*

注解	说明
@Configuration	用于指定当前类是一个Spring配置类，当创建容器时会从该类上加载注解
@ComponentScan	用于指定Spring在初始化容器时要扫描的包。作用和在Spring的xml配置文件中的—样
@Bean	使用在方法上，标注将该方法的返回值存储到Spring容器中
@PropertySource	用于加载.properties文件中的配置
@lmport	用于导入其他配置类

利用新注解可完全不用XML来配置了

1.目录

2.SpringConfiguration和DataSourceConfiguration文件

package com.home.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.import;

//标志该类是Spring的核心配置类
@Configuration
//
@ComponentScan("com.home")
//
@import({DataSourceConfiguration.class})
public class SpringConfiguration {
}

package com.home.config;
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;
import javax.sql.DataSource;

//
@PropertySource("classpath:jdbc.properties")
public class DataSourceConfiguration {

    @Value("${jdbc.driver}")
    private  String driver;
    @Value("${jdbc.url}")
    private  String url;
    @Value("${jdbc.username}")
    private  String username;
    @Value("${jdbc.password}")
    private  String password;

    @Bean("dataSource")  //Spring会将当前方法的返回值以指定名称存储到Spring容器中
    public DataSource getDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driver);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }
}

3.测试类里

public class Start {
    @Test
    public void test1(){
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        UserService userService = (UserService) app.getBean("userService");
        userService.save();
    }
}

3.Spring集成Junit

1.导入spring-test和junit依赖

2.测试类中

package com.home.test;

import com.home.config.SpringConfiguration;
import com.home.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import javax.sql.DataSource;
import java.sql.SQLException;

@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration("classpath:applicationContext.xml")
@ContextConfiguration(classes = {SpringConfiguration.class})

public class SpringJunit {
    @Autowired
    private UserService userService;
    @Autowired
    private DataSource dataSource;
    @Test
    public void test1() throws SQLException {
        userService.save();
        System.out.println(dataSource.getConnection());
    }
}
on;

@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration("classpath:applicationContext.xml")
@ContextConfiguration(classes = {SpringConfiguration.class})

public class SpringJunit {
    @Autowired
    private UserService userService;
    @Autowired
    private DataSource dataSource;
    @Test
    public void test1() throws SQLException {
        userService.save();
        System.out.println(dataSource.getConnection());
    }
}

Spring基础入门学习【持续更新】

Java相关栏目本月热门文章