spring入门

发布于：2025-07-22 ⋅ 阅读:(13) ⋅ 点赞:(0)
IOC -- Inverse of Control，控制反转，将对象的创建权力反转给 Spring 框架！！
控制反转（Inversion of Control，缩写为 IoC），是面向对象编程中的一种设计
原则，可以用来减低计算机代码之间的耦合度。
解决问题：使用 IOC 可以解决的程序耦合性高的问题！！Spring 的工厂读取配
置文件。

1.Spring 框架的优点

1.方便解耦，简化开发，Spring 就是一个大工厂，可以将所有对象创建和依赖关
系维护，交给 Spring 管理。IOC 的作用。
2.AOP 编程的支持，Spring 提供面向切面编程，可以方便的实现对程序进行权限
拦截、运行监控等功能。（可扩展性）
3.声明式事务的支持，只需要通过配置就可以完成对事务的管理，而无需手动编
程。
4.方便程序的测试，Spring 对 Junit4 支持，可以通过注解方便的测试 Spring 程
序。
5.方便集成各种优秀框架，Spring 不排斥各种优秀的开源框架，其内部提供了对
各种优秀框架（如：Struts2、Hibernate、MyBatis、Quartz 等）的直接支持。6.降低 JavaEE API 的使用难度，Spring 对 JavaEE 开发中非常难用的一些 API
（JDBC、JavaMail、远程调用等），都提供了封装，使这些 API 应用难度大大降
低。

2.Spring 的 IOC 核心技术 

IOC -- Inverse of Control，控制反转，将对象的创建权力反转给 Spring 框架！！
控制反转（Inversion of Control，缩写为 IoC），是面向对象编程中的一种设计
原则，可以用来减低计算机代码之间的耦合度。
解决问题：使用 IOC 可以解决的程序耦合性高的问题！！Spring 的工厂读取配
置文件。

IOC 的程序入门

创建 Java 工程，导入坐标依赖 
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
编写接口和实现类，编写具体的实现方法 
package com.qcbyjy.service;
public interface UserService {
public void hello();
}
package com.qcbyjy.service;
public class UserServiceImpl implements UserService {
@Override
public void hello() {
System.out.println("Hello IOC!!");
}
}
编写 Spring 核心的配置文件，在 src 目录下创建 applicationContext.xml 的配置
文件，名称是可以任意的，但是一般都会使用默认名称。 
<?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">
<!--IOC 管理 bean-->
<bean id="userService" class="com.qcbyjy.service.UserServiceImpl"
/>
</beans>
把 log4j.properties 的配置文件拷贝到 resources 目录下，做为 log4j 的日志配置
文件。
编写测试方法 
package com.qcbyjy.test;
import com.qcbyjy.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.ClassPathXmlApplicationContext;
public class Demo1 {
/**
* 入门程序
*/
@Test
public void run1(){
// 使用 Spring 的工厂
ApplicationContext applicationContext = new
ClassPathXmlApplicationContext("applicationContext.xml");
// 通过工厂获得类:
UserService userService = (UserService)
applicationContext.getBean("userService");
userService.hello();
}
}
IOC 技术总结
ApplicationContext 接口，工厂的接口，使用该接口可以获取到具体的 Bean 对
象。该接口下有两个具体的实现类。 springCould 配置中心
ClassPathXmlApplicationContext，加载类路径下的 Spring 配置文件。
FileSystemXmlApplicationContext，加载本地磁盘下的 Spring 配置文件。

3.实例化 Bean 对象的三种方式

默认是无参数的构造方法（默认方式，基本上使用） 
<bean id="us" class="com.qcbyjy.service.UserServiceImpl" />
静态工厂实例化方式 
package com.qcbyjy.demo1;
import com.qcbyjy.service.UserService;
import com.qcbyjy.service.UserServiceImpl;
/**
* 静态工厂方式
*/
public class StaticFactory {
// 静态工厂方式
public static UserService createUs(){
System.out.println("通过静态工厂的方式创建 UserServiceImpl 对
象...");
// 编写很多业务逻辑 权限校验
return new UserServiceImpl();
}
}
<bean id="us" class="com.qcbyjy.demo1.StaticFactory"
factory-method="createUs" />
实例工厂实例化方式 
package com.qcbyjy.demo1;
import com.qcbyjy.service.UserService;
import com.qcbyjy.service.UserServiceImpl;
/**
*
* 动态工厂方式
*
*/
public class Dfactory {
public UserService createUs(){
System.out.println("实例化工厂的方式...");
return new UserServiceImpl();
}
}
<bean id="dfactory" class="com.qcbyjy.demo1.Dfactory" />
<bean id="us" factory-bean="dfactory" factory-method="createUs" />

4.DI 依赖注入

IOC 和 DI 的概念
IOC：Inverse of Control，控制反转，将对象的创建权反转给 Spring！！
DI：Dependency Injection，依赖注入，在 Spring 框架负责创建 Bean 对象时，
动态的将依赖对象注入到 Bean 组件中！！

属性的 set 方法注入值

编写属性，提供该属性对应的 set 方法，编写配置文件完成属性值的注入 
package com.qcbyjy.service;
import com.qcbyjy.dao.OrderDao;
public class OrderServiceImpl implements OrderService {
// 编写成员属性，一定需要提供该属性的 set 方法
private OrderDao orderDao;
// 一定需要提供该属性的 set 方法，IOC 容器底层就通过属性的 set 方法方式注
入值
public void setOrderDao(OrderDao orderDao) {
this.orderDao = orderDao;
}
// 消息
private String msg;
// 年龄
private int age;
public void setMsg(String msg) {
this.msg = msg;
}
public void setAge(int age) {
this.age = age;
}
@Override
public void saveOrder() {
System.out.println("业务层：保存订单..."+msg+" - "+age);
// 调用
orderDao.saveOrder();
}
}

package com.qcbyjy.dao;
public class OrderDaoImpl implements OrderDao {
@Override
public void saveOrder() {
System.out.println("持久层：保存订单...");
}
}
<!--DI：依赖注入-->
<bean id="os" class="com.qcbyjy.service.OrderServiceImpl">
<property name="orderDao" ref="od" />
<property name="msg" value="你好" />
<property name="age" value="30" />
</bean>
<bean id="od" class="com.qcbyjy.dao.OrderDaoImpl"></bean>

属性构造方法方式注入值

对于类成员变量，构造函数注入。 
package com.qcbyjy.demo2;
public class Car {
// 名称
private String cname;
// 金额
private Double money;
public Car(String cname, Double money) {
this.cname = cname;
this.money = money;
}
@Override
public String toString() {
return "Car{" +
"cname='" + cname + '\'' +
", money=" + money +
'}';
}
}
<bean id="car" class="com.qcbyjy.demo2.Car">
<constructor-arg name="cname" value="大奔" />
<constructor-arg name="money" value="400000" />
</bean>

数组，集合(List,Set,Map)，Properties 等的注入

package com.qcbyjy.demo3;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
public class CollectionBean {
// 数组
private String [] strs;
public void setStrs(String[] strs) {
this.strs = strs;
}
private List<String> list;
public void setList(List<String> list) {
this.list = list;
}
private Map<String,String> map;
public void setMap(Map<String, String> map) {
this.map = map;
}
private Properties properties;
public void setProperties(Properties properties) {
this.properties = properties;
}
@Override
public String toString() {
return "CollectionBean{" +
"strs=" + Arrays.toString(strs) +
", list=" + list +
", map=" + map +
", properties=" + properties +
'}';
}
}
<!--给集合属性注入值-->
<bean id="collectionBean"
class="com.qcbyjy.demo3.CollectionBean">
<property name="strs">
<array>
<value>美美</value>
<value>小凤</value>
</array>
</property>
<property name="list">
<list>
<value>熊大</value>
<value>熊二</value>
</list>
</property>
<property name="map">
<map>
<entry key="aaa" value="老王"/>
<entry key="bbb" value="小王"/>
</map>
</property>
<property name="properties">
<props>
<prop key="username">root</prop>
<prop key="password">123456</prop>
</props>
</property>
</bean>

5.Spring 框架开发方式

1. 需求：编写 service 和 dao 的类，演示代码
2. 技术选择：持久层使用原始的 JDBC 的程序，连接池选择的是 Druid 连接池。创
建 maven 工程，导入开发的 jar 包 
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!--连接池-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.10</version>
</dependency>
<!--mysql 驱动包-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
</dependencies>
创建数据库，创建表结构 
create database spring_db;
use spring_db;
create table account(
id int primary key auto_increment,
name varchar(40),
money double
)character set utf8 collate utf8_general_ci;
insert into account(name,money) values('aaa',1000);
insert into account(name,money) values('bbb',1000);
insert into account(name,money) values('ccc',1000);
编写 JavaBean 的类 
package com.qcbyjy.domain;
import java.io.Serializable;
public class Account implements Serializable {
private static final long serialVersionUID = 7355810572012650248L;
private Integer id;
private String name;
private Double 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;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
'}';
}
}
编写 AccountDao 的接口和实现类 
package com.qcbyjy.dao;
import com.qcbyjy.domain.Account;
import java.util.List;
public interface AccountDao {
public List<Account> findAll();
}
package com.qcbyjy.dao;
import com.qcbyjy.domain.Account;
import com.alibaba.druid.pool.DruidDataSource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class AccountDaoImpl implements AccountDao {
// 注入连接池对象
private DataSource dataSource;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
/**
* 查询所有的数据
* @return
*/
@Override
public List<Account> findAll() {
/*
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///spring_db");
dataSource.setUsername("root");
dataSource.setPassword("root");
*/
List<Account> list = new ArrayList<>();
Connection connection = null;
PreparedStatement stmt = null;
ResultSet rs = null;
try {
// 获取连接
connection = dataSource.getConnection();
// 编写 sql 语句
String sql = "select * from account";
// 预编译
stmt = connection.prepareStatement(sql);
// 查询
rs = stmt.executeQuery();
// 遍历，封装数据
while (rs.next()){
Account account = new Account();
account.setId(rs.getInt("id"));
account.setName(rs.getString("name"));
account.setMoney(rs.getDouble("money"));
list.add(account);
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return list;
}
}

package com.qcbyjy.service;
import com.qcbyjy.domain.Account;
import java.util.List;
public interface AccountService {
public List<Account> findAll();
}
package com.qcbyjy.service;
import com.qcbyjy.dao.AccountDao;
import com.qcbyjy.domain.Account;
import java.util.List;
public class AccountServiceImpl implements AccountService {
// 依赖注入
private AccountDao accountDao;
public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}
/**
* 查询所有的数据
* @return
*/
@Override
public List<Account> findAll() {
return accountDao.findAll();
}
}

编写配置文件 
<?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.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"
/>
<property name="url" value="jdbc:mysql:///spring_db" />
<property name="username" value="root" />
<property name="password" value="root" />
</bean>
<!--管理 bean-->
<bean id="accountService"
class="com.qcbyjy.service.AccountServiceImpl">
<property name="accountDao" ref="accountDao" />
</bean>
<bean id="accountDao" class="com.qcbyjy.dao.AccountDaoImpl">
<property name="dataSource" ref="dataSource" />
</bean>
</beans>

编程测试程序 
package com.qcbyjy.test;
import com.qcbyjy.domain.Account;
import com.qcbyjy.service.AccountService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;
public class Demo1 {
@Test
public void run1(){
ApplicationContext ac = new
ClassPathXmlApplicationContext("applicationContext.xml");
AccountService accountService = (AccountService)
ac.getBean("accountService");
// 调用方法
List<Account> list = accountService.findAll();
for (Account account : list) {
System.out.println(account);
}
}
}

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布