Spring入门

Spring

Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。

DI 依赖注入

◆目的：解决企业应用开发的复杂性

◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能

◆范围：任何Java应用

普通对象的创建：

方式一：

User user=new User();

方式二反射（可以达到解耦）：

Object object = Class.forName("com.testfan.ioc.User").newInstance();

Spring对象的创建：

第一种方式：

通过xml维护bean对象

调用

//spring ioc
//spring.xml是bean的配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
User user2= (User) context.getBean("user");

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">

	<bean class="com.testfan.ioc.User" id="user" scope="singleton"></bean>
</beans>

第二种方式：

注解加包扫描

@Component //注解
public class Car {
	
	private Car() {
		System.out.println("create Car ");
	}

}

xml配置中添加包扫描

	  <!-- 对象第二种管理方式包扫描  -->
    <context:component-scan
		base-package="com.testfan.ioc" />

注意会爆红:

补全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"
	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">

调用

Car car = (Car) context.getBean("car"); //by name
User user =(User) context.getBean(Car.class);//by type
System.out.println(car);

注意：

@Component 如果默认没有添加名字的话使用默认的类名小写context.getBean("car")
@Component(cartest)  默认的时候要用context.getBean("cartest")

单例模式：

spring的单例模式：

xml：

//scope="singleton"单例模式  scope="prototype"非单例模式，每次创建一个新的对象
<bean class="com.testfan.ioc.User" id="user" scope="singleton"></bean> 

注解：

@Scope("prototype") 默认不添加注解就是非单例模式添加的时候就是单例模式

手写单例模式

口诀：构造方法私有化

//手写单例
public class Singleton {
	private static Singleton singleton;
	
	
	public static synchronized Singleton getSingleton() {
		if(singleton==null) {
			singleton =new Singleton();
		}
		return singleton;
	}
	

	private Singleton() {
		System.out.println("create Singleton ");
	}
	
	public static void main(String[] args) {
		Singleton singleton =new Singleton();
		Singleton singleton2 =new Singleton();
	}
}
 

DI：

依赖注入

第一种方法xml：

注意需要写set方法，不然会报错

	<bean class="com.testfan.ioc.User" id="user" scope="singleton">
	<property name="car" ref="cartest"></property> //配置需要注入的类名car ，ref是获取时候的名称
	</bean>

调用：

ApplicationContext context = new ClassPathXmlApplicationContext("spring1.xml");
User user =(User) context.getBean("user");
System.out.println(user.getCar());

第二种注解：

	@Autowired//注意需要写get方法，不需要set方法 by name
	@Autowired(required=flase) //如果添加了required，不检查这个类是不是存在 
	private User user;

	@Resource(name="user") by type
	private User user;

	public User getUser() {
		return user;
	}

调用：

Car car = (Car) context.getBean("car");
System.out.println("user1"+car.getUser());

输出结果：
user1User [name=null, sex=null, age=0]

javabean中值的定义：

第一种：

普通值的定义

xml中添加：

<bean class="com.testfan.ioc.User" id="user" scope="singleton">
<property name="car" ref="cartest"></property>
<property name="name" value="zhangsan"></property> //赋值给name
</bean>

list类型值添加

		<property name="carList">
			<list>
			<ref bean="cartest"/>
			<ref bean="cartest"/>
			</list>
		</property>

set类型值添加

		<property name="carSet">
			<set>
			<ref bean="cartest"/>
			<ref bean="cartest"/>
			</set>
		</property>

第二种读取properties

properties

name=u5f20u4e09u0089
num=101

xml中添加如下，用来解析properties

	<context:property-placeholder
		location="classpath*:test.properties" />

user对象

注解方式获取

@Component("cartest")
public class Car {
	@Value("${name}")
	private String name;
	@Value("${num}")
	private double price;

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	
	@Override
	public String toString() {
		return "Car [name=" + name + ", price=" + price + "]";
	}
}

xml中的获取

<bean class="com.testfan.ioc.User" id="user" scope="singleton">
		<property name="car" ref="cartest"></property>
		<property name="name" value="${name}"></property>//通过$获取到properties中的name值
	</bean>

m（业务）v（试图jsp）c(控制)

junit集成

	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.12</version>
		<scope>test</scope>
	</dependency>
	<dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-test</artifactId>  
        <version>${org.springframework-version}</version>
        <scope>provided</scope>  
    </dependency>

添加对应的注解

@RunWith(SpringJUnit4ClassRunner.class)//junit整合spring的
测试//立马开启了spring的注解
@ContextConfiguration(locations= {"classpath:spring1.xml"})//
加载核心配置文件
public class JunitTest {
	
	@Autowired
	User user;
	
	@Test
	public void test() {
		System.err.println(user);
		assertTrue("成功",true);
	}
	
}

testng的集成

mvn依赖

		<dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-test</artifactId>  
            <version>${org.springframework-version}</version>
            <scope>provided</scope>  
        </dependency> 
              <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
			<version>${testng.version}</version>
            <scope>test</scope>
        </dependency>

代码实列：

@ContextConfiguration(locations = { "classpath:spring1.xml" })//添加对应的注解
public class NewTest {
//	@Autowired
//	Car car;
	
	@Test
	public void f() {
		ApplicationContext context = new ClassPathXmlApplicationContext("spring1.xml");
		Car car = (Car) context.getBean("cartest");
		System.out.println("user"+car.getUser());
	}

}

spring_jdbctemplate（数据库）

mvn依赖包

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version> 当前系统版本 </version>
<scope>provided</scope>
</dependency>
	</dependency>
			<dependency>
			<groupId>com.mchange</groupId>
			<artifactId>c3p0</artifactId>
			<version>0.9.5.4</version>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>8.0.18</version>
		</dependency>

当前版本一般是指spring的版本号：

${org.springframework-version}

jdbc.properties配置文件配置

jdbc.driverClass=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://118.24.13.38:3308/goods?characterEncoding=utf-8&useSSL=false
jdbc.username=zhangsan
jdbc.password=123123
jdbc.initPoolSize=5
jdbc.maxPoolSize=10

spring-db.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"
	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">
	<!-- 导入资源文件 -->
	<context:property-placeholder location="classpath:jdbc.properties"/>
	
	<!-- 配置 c3p0 数据源 -->
	<bean id="dataSource"
		class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="user" value="${jdbc.username}"></property>	
		<property name="password" value="${jdbc.password}"></property>	
		<property name="jdbcUrl" value="${jdbc.url}"></property>	
		<property name="driverClass" value="${jdbc.driverClass}"></property>	
		<property name="initialPoolSize" value="${jdbc.initPoolSize}"></property>	
		<property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>	
	</bean>
	
	<!-- 配置 spring 的 JdbcTemplate -->
	<bean id="jdbcTemplate"
		class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	

</beans>

代码：

TestUserd对象

package com.testfan.jdbc;


/**
 * @author pc
 *
 */
public class TestUser {
	private String uid;
	private String loginname;
	private String loginpass;
	public String getUid() {
		return uid;
	}
	public void setUid(String uid) {
		this.uid = uid;
	}
	public String getLoginname() {
		return loginname;
	}
	public void setLoginname(String loginname) {
		this.loginname = loginname;
	}
	public String getLoginpass() {
		return loginpass;
	}
	public void setLoginpass(String loginpass) {
		this.loginpass = loginpass;
	}
	@Override
	public String toString() {
		return "TestUser [uid=" + uid + ", loginname=" + loginname + ", loginpass=" + loginpass + "]";
	}
}

jdbc代码实现

import java.util.List;
import java.util.Map;

import org.junit.Test;
import org.junit.runner.RunWith;
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.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)	
@ContextConfiguration(locations = {"classpath:spring-db.xml"})
public class SpringJdbcTest {
	
	@Autowired
	JdbcTemplate jdbcTemplate;
	
	@Test
	public void testUpdate() {
		String sql = "UPDATE t_user_test SET loginname = ? WHERE uid = ?";
		jdbcTemplate.update(sql, "test1","1");
	}
	
	@Test
	public void testQueryOne() {
		String sql = "select * from t_user_test where uid =?";
		RowMapper<TestUser> rowMapper = new BeanPropertyRowMapper<>(TestUser.class);
		TestUser user = jdbcTemplate.queryForObject(sql, rowMapper,"1");
		System.out.println(user);
	}
	
	@Test
	public void testQueryForList() {
		String sql = "select * from t_user_test";
		RowMapper<TestUser> rowMapper = new BeanPropertyRowMapper<>(TestUser.class);
		List<TestUser> user = jdbcTemplate.query(sql, rowMapper);
		System.out.println(user.size());
	}
	
	@Test
	public  void testQueryMap() {
		String sql = "select * from t_user_test";
		List<Map<String, Object>> user = jdbcTemplate.queryForList(sql);
		System.out.println(user);
	}
	
	

}