快速入门

Spring程序开发步骤

导入Spring开发的基本包坐标
编写Dao接口和实现类(创建Bean)
在resources目录下创建Spring类核心配置文件applicationContext.xml
在Spring配置文件中配置UserDaoImpl

<bean id="userDao" class="com.dao.impl.UserDaoImpl"></bean>

创建applicationContext对象getBean

ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) app.getBean("userDao");
userDao.save();

bean的属性

id
class
scope
- singleton：单例的（默认值）。在Spring核心文件被加载时，实例化配置的Bean实例，只会实例化这一次
- prototype：多例的。当调用getBean()方法时实例化Bean，调用一次实例化一次
- request：web项目中，Spring创建一个Bean的对象，将对象的值存放在request中
- session：
- global session：

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

bean中的标签

<property>
- name属性: 属性名称
- value属性：注入普通属性值
- ref属性：注入的对象引用值
- <list>标签
- <map>标签
- <properties>标签
<constructor-arg>

Bean实例化的三种方式

无参构造方法实例化（最常用）

<bean id="userDao" class="com.dao.impl.UserDaoImpl"></bean>

工厂静态方法实例化

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

<bean id="userDao" class="com.factory.StaticFactory"
factory-method="getUserDao"></bean>

工厂实例方法实例化

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

<bean id="factory" class="com.factory.DynamicFactory"></bean>
<bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>

依赖注入

依赖注入，是Spring框架核心IOC（控制反转）的具体体现

构造方法

public class UserServiceImpl implements UserService {
    private UserDao userDao;

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

    public UserServiceImpl() {
    }

    public void save() {
//        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
//        UserDao userDao = (UserDao) app.getBean("userDao");
        userDao.save();
    }
}

<bean id="userDao"
      class="com.dao.impl.UserDaoImpl"
></bean>
<bean id="userService" class="com.service.impl.UserServiceImpl">
    <constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

set方法

public class UserServiceImpl implements UserService {
    private UserDao userDao;

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

    public void save() {
//        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
//        UserDao userDao = (UserDao) app.getBean("userDao");
        userDao.save();
    }
}

<bean id="userDao" class="com.dao.impl.UserDaoImpl"></bean>
<bean id="userServic"           class="com.service.impl.UserServiceImpl">
    <property name="userDao" ref="userDao"></property>
</bean>
// property中的name属性是setUserDao，除set后，首字母小写得来的

<bean id="userService" class="com.service.impl.UserServiceImpl" p:userDao-ref="userDao">
</bean>

Spring配置数据源

数据源的开发步骤

导入数据源的坐标和数据库驱动坐标
创建数据源对象
设置数据源的基本连接数据
使用数据源获取资源和归还连接资源

手动配置数据源

@Test
// 测试c3p0数据源
public void test1() throws PropertyVetoException, SQLException {
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setDriverClass("com.mysql.jdbc.Driver");
    dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
    dataSource.setUser("root");
    dataSource.setPassword("370370");
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
    connection.close();
}

@Test
// 测试Druid数据源
public void test2() throws SQLException {
    DruidDataSource dataSource = new DruidDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://localhost:3306/test");
    dataSource.setUsername("root");
    dataSource.setPassword("370370");
    DruidPooledConnection connection = dataSource.getConnection();
    System.out.println(connection);
    connection.close();
}

抽取jdbc.properties文件（resources目录下）

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

@Test
// 测试手动创建c3p0数据源（加载properties配置文件）
public void test3() throws Exception{
    // 读取配置文件
    ResourceBundle rb = ResourceBundle.getBundle("jdbc");
    String driver = rb.getString("jdbc.driver");
    String url = rb.getString("jdbc.url");
    String username = rb.getString("jdbc.username");
    String password = rb.getString("jdbc.password");
    // 创建数据源对象，设置连接参数
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setDriverClass(driver);
    dataSource.setJdbcUrl(url);
    dataSource.setUser(username);
    dataSource.setPassword(password);
    Connection connection = dataSource.getConnection();
    System.out.println("@@@@@@@@@@@@@@@@@" + connection);
    connection.close();
}

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
    http://www.springframework.org/schema/beans/spring-beans.xsd">
   
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"></property>
        <property name="user" value="root"></property>
        <property name="password" value="370370"></property>
    </bean>
</beans>

@Test
    public void test4() throws Exception {
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource = (DataSource) app.getBean("dataSource");
//        DataSource dataSource = app.getBean(DataSource.class);
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

Spring加载properties文件

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

<?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">
    <!--加载外部的properties文件-->
    <context:property-placeholder location="classpath:jdbc.properties" />

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
</beans>

Spring注解开发

Spring原始注解

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

//@Component("userDao")
@Repository("userDao")
public class UserDaoImpl implements UserDao {
    public UserDaoImpl() {
        System.out.println("UserDaoImpl创建...");
    }

    @PostContruct
    public void init(){
        System.out.println("初始化方法....");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("销毁方法....");
    }
    public void save() {
        System.out.println("save running...");
    }
}

@Service("userService")
@Scope("singleton")
public class UserServiceImpl implements UserService {
    @Value("${jdbc.driver}")
    private String driver;
   // @Autowired  // 只写@Autowired，也能注入，是按照类型从Spring容器中进行匹配的 
   //  @Qualifier("userDao")  // 是按照id的值从容器中进行匹配的，但是注意此处@Qualifier必须结合@Autowired一起用
    
    @Resource(name = "userDao") // 相当于@Autowired+@Qualifier
    private UserDao userDao;
    // 使用xml配置方法，set方法一定要写，但如果是使用注解，set方法可以不用写
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public UserServiceImpl() {
    }

    public void save() {
        userDao.save();
    }
}

public class UserController {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = app.getBean(UserService.class);
        userService.save();
    }
}

<!--    <bean id="userDao" class="com.dao.impl.UserDaoImpl"></bean>-->

   <!-- <bean id="userService" class="com.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>-->

    <!--配置组件扫描-->
    <context:component-scan base-package="com" />

Spring新注解

原始注解不能做到的：

非自定义的Bean的配置：<bean>
加载properties文件的配置：<context:property-placeholder>
组件扫描的配置：<context:component-scan>
引入其他文件：<import>

新注解

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

package com.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.*;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;

// 标志该类是Spring的核心配置类
@Configuration
//<context:component-scan base-package="com" />
@ComponentScan("com")
//<context:property-placeholder location="classpath:jdbc.properties" />
@PropertySource("classpath:jdbc.properties")
//<import resource="" />
//@Import(DataSourceConfiguration.class)
public class SpringConfiguration {
    @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() throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

public class UserController {
    public static void main(String[] args) {
//        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        UserService userService = app.getBean(UserService.class);
        userService.save();
    }
}