1、 新建文件夹learn_spring
2、在idea,File-Open ,打开文件夹learn_spring
3、新建module, 取名为spring_ioc
4、File-Project Structure,然后点击 + ,选择web,选择要添加的模块,然后修改里面的路径
工程新建完成
5、修改pom.xml, 导包
<?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>com.tuy</groupId>
<artifactId>spring_ioc</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>RELEASE</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.11</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.0.9</version>
</dependency>
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<!-- spring集成junit需要的包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
</dependencies>
</project>
6、在src/main/java下 新建包 com.tuy.dao.impl ,com.tuy.demo , com.tuy.domain , com.tuy.service ,com.tuy.service.impl
7、编写dao层代码
package com.tuy.dao.impl;
import com.tuy.dao.UserDao;
//dao层(持久层)
public class UserDaoImpl implements UserDao {
public UserDaoImpl() {
System.out.println("UserDaoImpl Create....");
}
public void init(){
System.out.println("Init method....");
}
public void destory(){
System.out.println("destory method....");
}
public void save() {
System.out.println("save running...");
}
}
package com.tuy.dao;
public interface UserDao {
public void save();
}
9、编写service层代码
package com.tuy.service.impl;
import com.tuy.dao.UserDao;
import com.tuy.domain.User;
import com.tuy.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;
import java.util.Map;
import java.util.Properties;
//业务层
public class UserServiceImpl implements UserService {
private UserDao userDao;
//需要把dao注入到service,需要在配置文件 applicationContext.xml里面配置
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public UserServiceImpl()
{
}
public UserServiceImpl(UserDao userDao)
{
this.userDao=userDao;
}
public void save() {
userDao.save();
System.out.println(username+","+age);
System.out.println(strList);
System.out.println(userMap);
System.out.println(properties);
}
//普通属性
private String username;
private int age;
public void setUsername(String username) {
this.username = username;
}
public void setAge(int age) {
this.age = age;
}
//集合
private List<String> strList;
private Map<String, User> userMap;
private Properties properties;
public void setStrList(List<String> strList) {
this.strList = strList;
}
public void setUserMap(Map<String, User> userMap) {
this.userMap = userMap;
}
public void setProperties(Properties properties) {
this.properties = properties;
}
}
package com.tuy.service;
public interface UserService {
public void save();
}
10、 编写User
package com.tuy.domain;
public class User {
private String name;
private String addr;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", addr='" + addr + '\'' +
'}';
}
}
11、编写web层(这里是模拟的)
package com.tuy.demo;
import com.tuy.dao.UserDao;
import com.tuy.service.UserService;
import com.tuy.service.impl.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
//UserController 模拟web层
public class UserController {
public static void main(String[] args) {
//ClassPathXmlApplicationContext 它是从类的根路径下加载配置文件 推荐使用这种, 在resource目录下
ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
// 产生业务层的对象
// UserService userService1 = (UserService) app.getBean("userService"); //app.getBean("id")
UserService userService1 = app.getBean(UserService.class);//不适合配置文件有多个相同id
userService1.save();
}
}
12、编写配置文件applicationContext.xml,需要放在resources目录下
<?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:p="http://www.springframework.org/schema/p"
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">
<!-- dao层(持久层) -->
<!-- init-method指定初始化方法,destroy-method指定对象销毁方法 -->
<!-- 使用无参构造方法实例化 UserDaoImpl对象 -->
<bean id="userDao" class="com.tuy.dao.impl.UserDaoImpl" scope="singleton" init-method="init" destroy-method="destory"></bean>
<!-- 业务层-->
<!-- <bean id="userService" class="com.tuy.service.impl.UserServiceImpl" >-->
<!-- <!– 业务层依赖dao层,所以需要 把dao层对象注入到业务层 –>-->
<!-- <!–第一种方法 配置依赖注入, 配置属性的名字,需要是在UserServiceImpl的setUserDao方法中的set后面的userDao(首字母改为小写), –>-->
<!-- <!– ref的值是引用spring容器中bean的id –>-->
<!-- <property name="userDao" ref="userDao"></property>-->
<!-- </bean>-->
<!--____________-->
<!-- <bean id="userService" class="com.tuy.service.impl.UserServiceImpl" >-->
<!--第二种方法 通过有参构造方法来注入dao层依赖 -->
<!-- <!– 配置依赖注入, name是构造参数名字, ref的值是引用spring容器中bean的id –>-->
<!-- <!– ref 后面是要注入(引用)的bean对象的id –>-->
<!-- <constructor-arg name="userDao" ref="userDao"></constructor-arg>-->
<!-- </bean>-->
<!--____________-->
<!-- 第三种方法 依赖注入的方法: 需要引入命名空间 xmlns:p="http://www.springframework.org/schema/p" -->
<!-- 然后添加属性 p:userDao-ref="userDao" -->
<!-- <bean id="userService" class="com.tuy.service.impl.UserServiceImpl" p:userDao-ref="userDao" />-->
<bean id="user1" class="com.tuy.domain.User">
<property name="name" value="ton"></property>
<property name="addr" value="beijing"></property>
</bean>
<bean id="user2" class="com.tuy.domain.User">
<property name="name" value="ton2"></property>
<property name="addr" value="beijing2"></property>
</bean>
<bean id="userService" class="com.tuy.service.impl.UserServiceImpl" >
<!-- 业务层依赖dao层,所以需要 把dao层对象注入到业务层 -->
<!--第一种方法 配置依赖注入, 配置属性的名字,需要是在UserServiceImpl的setUserDao方法中的set后面的userDao(首字母改为小写), -->
<!-- ref的值是引用spring容器中bean的id -->
<property name="userDao" ref="userDao"></property>
<!--普通属性的注入-->
<property name="username" value="zhangsan"></property>
<property name="age" value="18"></property>
<!--集合性的注入-->
<!-- List-->
<property name="strList">
<list>
<!-- 集合里面的数据类型是普通数据类型,用value,否则用ref -->
<value>hha</value>
<value>cca</value>
</list>
</property>
<!--Map-->
<property name="userMap">
<map>
<entry key="user1" value-ref="user1"></entry>
<entry key="user1" value-ref="user2"></entry>
</map>
</property>
<!--Properties-->
<property name="properties">
<props>
<prop key="p1">pvaaa1</prop>
<prop key="p2">pvaaa2</prop>
<prop key="p3">pvaaa3</prop>
</props>
</property>
</bean>
<!-- 配置druid数据源 -->
<!-- <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">-->
<!-- <!– 配置属性,需要set方法后面的名字 –>-->
<!-- <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" ></property>-->
<!-- <property name="url" value="jdbc:mysql://localhost:3306/db1?serverTimezone=UTC" ></property>-->
<!-- <property name="username" value="root" ></property>-->
<!-- <property name="password" value="root" ></property>-->
<!-- </bean>-->
<!--加载外部的配置文件 jdbc.properties-->
<!--需要引入命名空间 xmlns:context="http://www.springframework.org/schema/context" -->
<!--需要引入命名空间 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 配置druid数据源 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<!-- 配置属性,需要set方法后面的名字 , 值 通过外部配置文件获取 -->
<property name="driverClassName" value="${jdbc.drive}" ></property>
<property name="url" value="${jdbc.url}" ></property>
<property name="username" value="${jdbc.username}" ></property>
<property name="password" value="${jdbc.passwrod}" ></property>
</bean>
<!-- 配置组件扫描, 使用spring注解开发时候需要配置的-->
<!-- <context:component-scan base-package="com.tuy" />-->
<!-- 引入其他配置文件,可以用来分模块开发-->
<!--<import resource="applicationContext-user.xml"/>-->
</beans>
13 创建 jdbc.properties 文件
jdbc.drive=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db1?serverTimezone=UTC
jdbc.username=root
jdbc.passwrod=root
14 新建com.tuy.test.DataSourceTest 测试类 ,测试通过spring 对配置文件的加载
package com.tuy.test;
import com.alibaba.druid.pool.DruidDataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import com.tuy.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import javax.sql.DataSource;
import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ResourceBundle;
public class DataSourceTest {
//创建c3p0数据源
@Test
public void test1() throws PropertyVetoException, SQLException {
ComboPooledDataSource dataSource=new ComboPooledDataSource();
dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/db1?serverTimezone=UTC");
dataSource.setUser("root");
dataSource.setPassword("root");
Connection connection=dataSource.getConnection();
System.out.println(connection);
connection.close();
}
//创建druid数据源
@Test
public void test2() throws SQLException {
DruidDataSource dataSource=new DruidDataSource();
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/db1?serverTimezone=UTC");
dataSource.setUsername("root");
dataSource.setPassword("root");
Connection connection=dataSource.getConnection();
System.out.println(connection);
connection.close();
}
//加载外部文件
public void test3()
{
//读取配置文件
ResourceBundle rb=ResourceBundle.getBundle("jdbc"); //加载类路径下的配置文件,不需要写后缀名字 , jdbc.properties
String drive=rb.getString("jdbc.drive");
String url=rb.getString("jdbc.url");
String username=rb.getString("jdbc.username");
String password=rb.getString("jdbc.password");
}
@Test
//spring容器产生数据源对象
public void test4() throws SQLException {
//ClassPathXmlApplicationContext 它是从类的根路径下加载配置文件 推荐使用这种, 在resource目录下
ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
// 产生业务层的对象
// UserService userService1 = (UserService) app.getBean("userService"); //app.getBean("id")
DataSource ds= app.getBean(DataSource.class);//不适合配置文件有多个相同id
Connection connection = ds.getConnection();
System.out.println(connection);
connection.close();
}
}
//-------------------------------------------------------------
使用注解开发,取代xml配置文件
修改dao层的类实现文件
package com.tuy.dao.impl;
import com.tuy.dao.UserDao;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
//<bean id="userDao" class="com.tuy.dao.impl.UserDaoImpl"></bean>
//@Component("userDao")
@Repository("userDao")
public class UserDaoImpl implements UserDao {
public void save() {
System.out.println("save running...");
}
}
修改业务层的类实现文件
package com.tuy.service.impl;
import com.tuy.dao.UserDao;
import com.tuy.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
//<bean id="userService" class="com.tuy.service.impl.UserServiceImpl">
//@Component("userService")
@Service("userService")
//@Scope("prototype")
@Scope("singleton")
public class UserServiceImpl implements UserService {
@Value("${jdbc.driver}")
private String driver;
//<property name="userDao" ref="userDao"></property>
//@Autowired //按照数据类型从Spring容器中进行匹配的
//@Qualifier("userDao") //是按照id值从容器中进行匹配的 但是主要此处@Qualifier结合@Autowired一起使用
@Resource(name="userDao") //@Resource相当于@Qualifier+@Autowired
private UserDao userDao;
public void save() {
System.out.println(driver);
userDao.save();
}
@PostConstruct
public void init(){
System.out.println("Service对象的初始化方法");
}
@PreDestroy
public void destory(){
System.out.println("Service对象的销毁方法");
}
}
新建数据源的配置类
package com.tuy.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;
//数据源的相关配置
// <context:property-placeholder location="classpath:jdbc.properties"/> 加载配置文件
@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 getDatsSource()
{
DruidDataSource dataSource=new DruidDataSource();
dataSource.setDriverClassName(driver);
dataSource.setUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource;
}
}
新建spring的核心配置 类
package com.tuy.cofig;
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.tuy"/>
@ComponentScan("com.tuy")
//<import resource=""/>
@Import({DataSourceConfiguration.class})
public class SpringCofiguration {
}
更改web层的代码
package com.itheima.web;
import com.itheima.cofig.SpringCofiguration;
import com.itheima.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class UserController {
public static void main(String[] args) {
//ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
ApplicationContext app = new AnnotationConfigApplicationContext(SpringCofiguration.class);
UserService userService = app.getBean(UserService.class);
userService.save();
}
}
//-----------------------------------------
Spring Junit 集成测试
package com.tuy.test;
import com.tuy.config.SpringConfiguration;
import com.tuy.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;
//springJunit集成测试
//spring-test
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
//@ContextConfiguration(classes = {SpringConfiguration.class}) //全注解的方式
public class SpringJunitTest {
@Autowired //测试哪个就把哪个注入进来
private UserService userService;
@Autowired
private DataSource dataSource;
@Test
public void test1() throws SQLException {
System.out.println("---test1----");
userService.save();
System.out.println(dataSource.getConnection());
System.out.println("---test1----");
}
}