引入

程序的耦合:

程序间的依赖关系:类之间的依赖,方法之间的依赖

解耦合:降低程序间的依赖关系(尽量做到编译器不依赖,运行时才依赖)

解耦方式:

  1. 使用反射创建类对象,避免使用new关键字
  2. 通过读取配置文件来获取要创建的对象全限定类名

Spring基于XML的开发

1.导入坐标依赖

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

2.编写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">
</beans>

3.导入Spring的配置文件

ApplicationContext的三个实现类:

  1. ClassPathXmlApplicationContext:
  2. FileSystemXmlApplicationContext:
  3. AnnotationConfigApplicationContext:

4.Spring的依赖注入

  1. 构造函数注入:

    标签:constructor-arg

    标签出现的位置:bean标签的内部

    常用标签的属性:

    (1)name:给指定构造函数中指定名称的参数赋值

    (2)value:用于提供基本类型和String类型的数据

    (3)ref:用于指定其他n的bean类型数据。它指的是在Spring的IOC核心容器中出现过的bean对象

    <bean id="accountService" class="com.service.Impl.AccountImpl">
        <constructor-arg name="name" value="张三"></constructor-arg>
        <constructor-arg name="age" value="20"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>
    package com.service.Impl;
    
    import com.Dao.IAccountDao;
    import com.Dao.Impl.AccountDaoImpl;
    import com.service.IAccountService;
    
    import java.text.DateFormat;
    import java.util.Date;
    
    public class AccountImpl implements IAccountService {
    
        private String name;
        private int age;
        private Date birthday;
    
        public AccountImpl(String name, int age, Date birthday) {
            this.name = name;
            this.age = age;
            this.birthday = birthday;
        }
    
        public void SaveAccount() {
            System.out.println(this.name + "   " + this.age + "   "+ this.birthday);
        }
    }
    

    主方法测试

    package com;
    
    

import com.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext(“bean.xml”);
IAccountService as = (IAccountService) ac.getBean(“accountService”);
as.SaveAccount();
}
}


2. set方法注入

   标签:property

   出现位置:bean标签内部

   标签的属性:

   (1)name:用于指定注入时所调用的set方法名称(**去掉前面的Set然后小写**)

   (2)value:用于提供基本类型和String类型的数据

   (3)ref:用于指定其他的bean类型数据。它指的是在Spring的IOC核心容器中出现过的bean对象,该数据类型需要先注入,然后在其他数据类型中通过,id注入。

3.注解方法注入

​    下面详细介绍

**5.Spring复杂数据类型的注入**

1. List集合注入的标签:list,array,set
2. Map集合注入的标签:map,props

### Spring基于注解的开发

#### 1.创建对象的注解

**Tip:首先要在XML配置文件中扫描注解**

```xml
<context:component-scan base-package="被扫描的包名"></context:component-scan>
  • @Component:将当前类对象存入Spring容器

    ​ 属性:value:指定bean的id(默认id为首字母小写的类名)

  • @Controller(表现层),@Service(业务层)@Repository(持久层):这三个注解功能与属性与@Component一致,只是Spring框架提供的明确的三层架构

2.注入数据的注解

  • @Autowirted:自动按照类型注入

    对于Autowirted,注入时必须使用已经存在bean,如果同时存在两个实现类继承了一个接口,需要使用@Qualifier进行区分,或者根据类名进行区分

  • @Qualifier:在原注入基础上根据名称注入

    ​ 属性:value 用于指定

  • @Resource:直接根据bean的id注入

    ​ 属性:name用于指定bean的id

  • @Value:用于注入基本数据类型和String类型

    ​ 属性:value用于指定数据的值

3.改变作用范围的注解

  • @Scope

    ​ 属性:value用于指定范围取值(singleton[单例],prototype[多例])

Spring基于XML的开发案例

利用Spring使用JDBC以及Druid代理池,实现对数据库的增删查改

依赖导入

<?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>SpringDay02</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.7</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.23</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
    </dependencies>
</project>

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">
    <!-- 配置Service   -->
    <bean id="accountService" class="com.Service.Impl.AccountServiceImpl">
        <!--通过set方法注入accountDao -->
        <property name="accountDao" ref="accountDao"></property>
    </bean>
    <!--配置Dao-->
    <bean id="accountDao" class="com.Dao.Impl.AccountDaoImpl">
        <!--通过set方法注入JdbcTemplate-->
        <property name="jt" ref="jt"></property>
    </bean>
    <!--配置JdbcTemplate-->
    <bean id="jt" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--由于JdbcTemplate不提供set方法,所以这里提供构造方法注入dataSource-->
        <constructor-arg name="dataSource" ref="dataSource"></constructor-arg>
    </bean>
    <!--配置DataSource-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!--注入mysql的用户名 密码 url 驱动-->
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///springdemo"></property>
        <property name="username" value="root"></property>
        <property name="password" value="sr20000316"></property>
    </bean>
</beans>

对于Spring基于XML的配置可以分为以下几个步骤:

1、配置类

2、对该类中的数据进行注入,具体是注入方式详见最上方

Account实体

package com.Bean;

import java.io.Serializable;

public class Account implements Serializable {
    private Integer id;
    private String name;
    private Integer 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 Integer getMoney() {
        return money;
    }

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

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

IAccountService接口

package com.Service;

import com.Bean.Account;

import java.util.List;

public interface IAccountService {

    public List<Account> findall();

    public Account findAccountById();

    public void saveAccount(Account account);

    public void updateAccount(Account account);

    public void deleteAccount(Integer id);
}

IAccountService实现类

package com.Service.Impl;

import com.Bean.Account;
import com.Dao.IAccountDao;
import com.Service.IAccountService;

import java.util.List;

public class AccountServiceImpl implements IAccountService {

    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public List<Account> findall() {
        return accountDao.findall();
    }

    public Account findAccountById() {
        return accountDao.findAccountById();
    }

    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    public void deleteAccount(Integer id) {
        accountDao.deleteAccount(id);
    }
}

IAccountDao接口

package com.Dao;

import com.Bean.Account;

import java.util.List;

public interface IAccountDao {
    public List<Account> findall();

    public Account findAccountById(Integer id);

    public void saveAccount(Account account);

    public void updateAccount(Account account);

    public void deleteAccount(Integer id);
}

IAccountDao接口实现类

package com.Dao.Impl;

import com.Bean.Account;
import com.Dao.IAccountDao;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import java.beans.BeanProperty;
import java.util.List;

public class AccountDaoImpl implements IAccountDao {

    private JdbcTemplate jt;

    public void setJt(JdbcTemplate jt) {
        this.jt = jt;
    }

    public List<Account> findall() {
        return jt.query("select* from account",new BeanPropertyRowMapper<Account>(Account.class));
    }

    public Account findAccountById(Integer id) {
        Object[] params = {id};
        List<Account> accounts = jt.query("select* from account where id = ?", params, new BeanPropertyRowMapper<Account>(Account.class));
        return accounts.get(0);
    }

    public void saveAccount(Account account) {
        Object[] params = {account.getId(),account.getName(),account.getMoney()};
        jt.update("insert into account values(?,?,?)",params);
    }

    public void updateAccount(Account account) {
        Object[] params = {account.getName(),account.getMoney(),account.getId()};
        jt.update("update account set name = ?,money = ? where id = ?",params);
    }

    public void deleteAccount(Integer id) {
        Object[] params = {id};
        jt.update("delete from account where id = ?",params);
    }

}

测试类

package com;

import com.Bean.Account;
import com.Service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class Demo {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService as =  (IAccountService) ac.getBean("accountService");
        //删除操作
        as.deleteAccount(2);
        Account account = new Account();
        account.setId(4);
        account.setMoney(3000);
        account.setName("王五");
        //新增操作
        as.saveAccount(account);
        //查找所有操作
        List<Account> accounts = as.findall();
        System.out.println(accounts);
        Account account2 = new Account();
        account2.setId(1);
        account2.setName("张三");
        account2.setMoney(30000);
        as.updateAccount(account2);
        //根据ID查找操作
        Account account1 = as.findAccountById(1);
        System.out.println(account1);

    }
}

Spring基于注解的开发案例

依赖注入

<?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>SpringDay02</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.7</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.23</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
    </dependencies>
</project>

IAccountService接口

package com.Service;

import com.Bean.Account;
import java.util.List;

public interface IAccountService {

    public List<Account> findall();

    public Account findAccountById(Integer id);

    public void saveAccount(Account account);

    public void updateAccount(Account account);

    public void deleteAccount(Integer id);
}

IAccountService实现类

package com.Service.Impl;

import com.Bean.Account;
import com.Dao.IAccountDao;
import com.Service.IAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service("accountService")
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public List<Account> findall() {
        return accountDao.findall();
    }

    public Account findAccountById(Integer id) {
        return accountDao.findAccountById(id);
    }

    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    public void deleteAccount(Integer id) {
        accountDao.deleteAccount(id);
    }
}

IAccountDao接口

package com.Dao;

import com.Bean.Account;

import java.util.List;

public interface IAccountDao {
    public List<Account> findall();

    public Account findAccountById(Integer id);

    public void saveAccount(Account account);

    public void updateAccount(Account account);

    public void deleteAccount(Integer id);
}

IAccountDao实现类

package com.Dao.Impl;

import com.Bean.Account;
import com.Dao.IAccountDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {
    @Autowired
    private JdbcTemplate jt;

    public List<Account> findall() {
        return jt.query("select* from account",new BeanPropertyRowMapper<Account>(Account.class));
    }

    public Account findAccountById(Integer id) {
        Object[] params = {id};
        List<Account> accounts = jt.query("select* from account where id = ?", params, new BeanPropertyRowMapper<Account>(Account.class));
        return accounts.get(0);
    }

    public void saveAccount(Account account) {
        Object[] params = {account.getId(),account.getName(),account.getMoney()};
        jt.update("insert into account values(?,?,?)",params);
    }

    public void updateAccount(Account account) {
        Object[] params = {account.getName(),account.getMoney(),account.getId()};
        jt.update("update account set name = ?,money = ? where id = ?",params);
    }

    public void deleteAccount(Integer id) {
        Object[] params = {id};
        jt.update("delete from account where id = ?",params);
    }

}

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">
    <context:component-scan base-package="com"></context:component-scan>
    <bean id="jt" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--由于JdbcTemplate不提供set方法,所以这里提供构造方法注入dataSource-->
        <constructor-arg name="dataSource" ref="dataSource"></constructor-arg>
    </bean>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!--注入mysql的用户名 密码 url 驱动-->
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///springdemo"></property>
        <property name="username" value="root"></property>
        <property name="password" value="sr20000316"></property>
    </bean>
</beans>

Spring的配置类

从上面的基于注解实现的IOC案例中,可以发现,虽然使用注解创建了对象,但是我们仍然需要配置文件来创建那些不是我们自己写的类,所以这里就再次引入三个注解,这样就可以在使用注解时完全脱离XML配置文件

  • @Configuration:指定当前类为一个配置类

  • @ComponentScan:通过注解指定Spring的创建容器中要扫描的包

    ​ 属性:value/basePackages:扫描某一个包 下的全部注解

  • @bean:用于把当前方法的返回值作为bean对象存入Spring的IOC容器中

  • @Import

    ​ 属性:value:导入其他的配置类,有Import注解的类是主配置类

  • @PropertySource

    ​ 属性:value:指定文件的名称和路径;classpath表示类路径下

package com.Config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

@Configuration
@ComponentScan("com")
public class SpringConfiguration {
    @Bean(name = "jdbc")
    public JdbcTemplate creatJDBC(DataSource ds){
        return new JdbcTemplate(ds);
    }

    @Bean(name = "dataSource")
    public DataSource createDateSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
        ds.setUsername("root");
        ds.setPassword("sr20000316");
        ds.setUrl("jdbc:mysql:///springdemo");
        return ds;
    }
}

当使用上面的三个注解以后,我们就可以完全脱离XML配置文件了,这里测试方法中要读取这个类

package com;

import com.Bean.Account;
import com.Config.SpringConfiguration;
import com.Service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class Demo {
    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        IAccountService as =  (IAccountService) ac.getBean("accountService");
        //删除操作
//        as.deleteAccount(2);
        Account account = new Account();
        account.setId(4);
        account.setMoney(3000);
        account.setName("王五");
        //新增操作
        as.saveAccount(account);
        //查找所有操作
        List<Account> accounts = as.findall();
        System.out.println(accounts);
        Account account2 = new Account();
        account2.setId(1);
        account2.setName("张三");
        account2.setMoney(30000);
        as.updateAccount(account2);
        //根据ID查找操作
        Account account1 = as.findAccountById(1);
        System.out.println(account1);
    }
}

实际开发中一般使用注解和XML混合使用