Spring基础

Spring基础

概念:

是一个轻量级的IOC(控制反转)和AOP(面向切面编程)的容器框架

轻量级:框架设计简单强大,使用方便

IOC:控制反转,将创建对象的权力交给Spring容器

AOP: 面向切面编程,将通用的逻辑提取出来,作用到控制器里卖面,可以看作升级版的过滤器

在企业级开发中,Spring通常用来整合其他层次的框架

Spring容器

BeanFactory

默认是在获取对象的时候创建对象

ApplicationContext

默认是在创建容器的时候创建对象,可以通过lazy-init=”true”配置懒加载,ApplicationContext是BeanFactory的子接口

获取对象的方式

通过ID

通过ID+字节码对象(推荐使用)

通过字节码对象

Spring配置细节

ID和name:推荐使用ID,推荐ID属性值为类名的首字母小写

作用域

默认是单例(每次获取的时候都是同一个对象)

多例(每次获取的对象都是新的对象)需要设置scope=”prototype”

懒加载

​ Beanfactory默认是懒加载–在获取或者使用的时候才加载

​ ApplicationContext

​ 单例时:默认在容器创建的时候就进行加载(迫切加载)设置单个Bean懒加载:lazy-init=”true”,设置所有Bean懒加载:default-lazy-init=”true”

​ 多例时:默认就是懒加载,因为不知道需要创建多少对象,只有在获取的时候才知道

Spring中对象或者Bean的生命周期

出生:Spring容器调用无参构造+指定的构造方法

销毁:Spring容器调用指定的销毁方法

Spring测试

概述

Spring对Junit的集成

作用

测试代码量减少

使用注解加载配置文件

使web项目测试更加方便

注解

@RunWith(SpringJUnit4ClassRunner.class)//启动Spring测试

@ContextConfiguration(“classpath:applicationContext.xml”)//加载配置文件

@Autowired //自动注入 – 将容器中已经存在的对象注入(给这个成员赋值)到使用的变量中

🎈Spring注入

注入方式

构造器注入,一般不使用,依赖性太强

Set注入,必须要有set方法,Set注入时name名必须和Set方法名一样,绝大多数情况下都是用setter方法注入,构造器注入了解

使用Spring和三层架构实现对数据库的增加和查询操作

思路:

1.创建数据库db0903 创建表user – id + name
2.创建包cn.itsource.project.dao – IuserDao接口 – void addUser(User user);
3.创建包cn.itsource.project.dao.impl – UserDaoImpl – void addUser(User user){}
4.创建创建包cn.itsource.project.domain – 实体类User
5.导入连接池2个+1个驱动包
6.将BasicDataSource交给Spring管理 – 注入4个 (driverClassName,url,username,password)bean属性
7.测试BasicDataSource对象的创建 和 连接的获取

8.编写实现类

9.然后测试

首先创建实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package com.ifueen.classtest.domain;

public class User {
private String name;
private Integer password;
private String nickname;
private String photo;
public User(String name, Integer password, String nickname) {
super();
this.name = name;
this.password = password;
this.nickname = nickname;
}
public User() {
super();
// TODO Auto-generated constructor stub
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getPassword() {
return password;
}
public void setPassword(Integer password) {
this.password = password;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
@Override
public String toString() {
return "User [name=" + name + ", password=" + password + ", nickname=" + nickname + ", photo=" + photo + "]";
}



}

Dao层

1
2
3
4
5
6
7
8
package com.ifueen.classtest.dao;

import com.ifueen.classtest.domain.User;

public interface IUser {
void addUser(User user);
User Query(Integer id);
}

Dao的实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
package com.ifueen.classtest.dao.impl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.apache.commons.dbcp.BasicDataSource;
import org.springframework.beans.factory.annotation.Autowired;

import com.ifueen.classtest.dao.IUser;
import com.ifueen.classtest.domain.User;

public class UserDaoImpl implements IUser{


private BasicDataSource datasource;

public BasicDataSource getDatasource() {
return datasource;
}

public void setDatasource(BasicDataSource datasource) {
this.datasource = datasource;
}



/*
*添加的方法
*/
@Override
public void addUser(User user) {
// TODO Auto-generated method stub
try {
Connection conn = datasource.getConnection();
String sql = "insert into user (name,password,nickname) values(?,?,?)";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, user.getName());
ps.setInt(2, user.getPassword());
ps.setString(3, user.getNickname());

ps.executeUpdate();
ps.close();
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

/*
* 查询的方法
*/
@Override
public User Query(Integer id) {
// TODO Auto-generated method stub
User user = new User();
try {
Connection conn = datasource.getConnection();
String sql="select * from user where id = ?";
PreparedStatement pc = conn.prepareStatement(sql);
pc.setInt(1, id);
ResultSet set = pc.executeQuery();
while(set.next()){
user.setName(set.getString("name"));
user.setPassword(set.getInt("password"));
user.setNickname(set.getString("nickname"));
}

} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return user;
}

}

xml文件的配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
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

http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd"
>


<!-- 配置context -->
<context:property-placeholder location="classpath:db.properties" system-properties-mode="NEVER" />

<!-- 连接池 -->
<bean id="datasource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${driverClassName}"></property>
<property name="url" value="${url}"></property>
<property name="username" value="${username}"></property>
<property name="password" value="${password}"></property>
</bean>

<bean id="dao" class="com.ifueen.classtest.dao.impl.UserDaoImpl">
<property name="datasource" ref="datasource"></property>
</bean>


<!-- 获取当前系统时间 -->
<bean id="date" class="java.util.Date"></bean>
<!-- 获取List集合 -->
<bean id="arraylist" class="java.util.ArrayList"></bean>

</beans>

最后在测试类中进行测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package com.ifueen.classtest.test;

import org.apache.commons.dbcp.BasicDataSource;
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 com.ifueen.classtest.bean.Person;
import com.ifueen.classtest.bean.Phone;
import com.ifueen.classtest.dao.impl.UserDaoImpl;
import com.ifueen.classtest.domain.User;

@RunWith(SpringJUnit4ClassRunner.class)//启动Spring测试
@ContextConfiguration("classpath:applicationContext.xml")//加载配置文件
public class SpringTest {

//@Autowired //自动注入 -- 将容器中已经存在的对象注入(给这个成员赋值)到使用的变量中
//Autowired先根据名字匹配,如果名字都没有匹配上,就根据类型来进行匹配

@Autowired
private BasicDataSource datasource;

@Autowired
private UserDaoImpl db;

@Test
public void testAdd() {
User user = new User("尊龙",20,"蝴蝶君");
db.addUser(user);
}
@Test
public void testQuery() {
User user = db.Query(2);
System.out.println(user);
}

}

资源文件db.properties

1
2
3
4
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/数据库名
username=用户名
password=密码
❤赏点钱让我买杯快乐水8❤