JavaWeb——Spring框架

一、介绍

Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言,绝大部分Java应用都可以从Spring中受益。
◆目的:解决企业应用开发的复杂性
◆功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能
◆范围:任何Java应用
Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。

  1. 通过IoC功能对项目内的应用进行解耦
  2. AOP面向切面编程 实现权限拦截、登陆验证、运行监测
  3. 可以管理事务
  4. 支持junit测试
  5. 支持其他框架
  6. 对JavaEE进行了封装

二、控制反转

控制反转:开发的项目中所有的依赖的类都不是程序本身来完成的,而是由其他程序来完成,创建对象的权力发生的转移,将创建对象权力给Spring

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd ">
			<!-- 创建实体类 -->
			<bean id="person" class="beer.onexone.beans.Person" ></bean>
</beans>

实体类:

package beer.onexone.beans;

public class Person {
			int age;
			String name;
			public Person() {
				super();
					System.out.println("创建成功");
			}	
}

测试

package beer.onexone.dao;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
	public static void main(String[] args) {
		// 读取配置文件
		new ClassPathXmlApplicationContext("applicationContext.xml");
	}
}

控制台

log4j:WARN No appenders could be found for logger (org.springframework.core.env.StandardEnvironment).
log4j:WARN Please initialize the log4j system properly.
创建成功

三、实例化bean的三种方式

  • 读取xml文件
  • 取出id=person class="……"
  • Class clazz = Class.ForName("");
  • clazz.newInstance();

1、XML中创建

<bean id="person" class="beer.onexone.beans.Person" > </bean>

2、静态工厂创建

			<bean id="personByStaticFactory" class="beer.onexone.utils.StaticBeanFactory"></bean>
public class StaticBeanFactory {
				public static Person getPersonBean() {
					return new Person();
				}
}

3、工厂模式创建

	<!-- 工厂模式创建实体类 -->
			<bean id="factory" class="beer.onexone.utils.BeanFactory"></bean>
			<bean id="personByFatory" factory-bean="factory"  factory-method="createPersonBean"></bean>
public class BeanFactory {
	public Person createPersonBean() {
		return new Person();
	}
}

四、依赖注入(DI)

1、通过构造方法注入

创建对象,赋属性值
依赖对象 在spring中创建的对象
依赖属性 对象中对应属性

	<!-- 依赖注入 -->
			<!-- 1、构造方法注入
			<bean id="" class="">
			<constructor-arg name="入参字段名" type="入参类型" ref="引入其他值"></constructor-arg>
			</bean> -->

2、通过set方法注入

<!-- 	2、set注入
			<bean id="" class="">
				<property name="入参字段名" value="入参值"></property>
				引入类型也可直接写在内部
				<property name="">
					<bean class=""></bean>
				</property>
			</bean> -->

五、各种属性类型的注入

实体类:

public class AllKindsOfBeans {
			private	int id;
			private String[] names;
			private	Person person;
			private	List<String> strings;
			private	List<Person> persons;
			private	Set<Person> set;
			private	Map<String, Person> map;
			private Properties properties;
}

xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://www.springframework.org/schema/beans"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd ">

	<bean id="allKindsOfBeans"
		class="beer.onexone.beans.AllKindsOfBeans">
		<!-- 集本数据类型 -->
		<property name="id" value="1" />
		<!-- 字符串数组 -->
		<property name="names">
			<array>
				<value>张国荣</value>
				<value>张曼玉</value>
			</array>
		</property>
		<!-- POJO类 -->
		<property name="person">
			<bean class="beer.onexone.beans.Person">
				<property name="age" value="23" />
				<property name="name" value="陈冠希" />
				<property name="date">
					<bean class=" java.util.Date"></bean>
				</property>
			</bean>
		</property>
		<!-- List -->
		<property name="strings">
			<list>
				<value>list1</value>
				<value>list2</value>
			</list>
		</property>
		<!-- set -->
		<property name="set">
			<set>
				<ref bean="person1" />
				<ref bean="person2" />
			</set>
		</property>
		<!-- Map -->
		<property name="map">
			<map>
				<entry key="P1">
					<ref bean="person1" />
				</entry>
			</map>
		</property>
		<!-- Properties -->
		<property name="properties">
			<props>
				<prop key="k1">v1</prop>
			</props>
		</property>
	</bean>

	<bean id="person1" class="beer.onexone.beans.Person">
		<property name="age" value="65" />
		<property name="name" value="易中天" />
		<property name="date">
			<bean class=" java.util.Date"></bean>
		</property>
	</bean>
	<bean id="person2" class="beer.onexone.beans.Person">
		<property name="age" value="55" />
		<property name="name" value="臼井仪人" />
		<property name="date">
			<bean class=" java.util.Date"></bean>
		</property>
	</bean>

</beans>

测试方法:

package beer.onexone.dao;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import beer.onexone.beans.AllKindsOfBeans;

public class All {
			public static void main(String[] args) {
			//获取配置文件
			ApplicationContext context = new ClassPathXmlApplicationContext("applicationContextALl.xml");
			AllKindsOfBeans allKindsOfBeans = context.getBean("allKindsOfBeans", AllKindsOfBeans.class);
			System.out.println(allKindsOfBeans);
			}
}

六、Bean标签的配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd ">
		<!-- 懒加载和单例模式 -->
		<bean id="personLazy" class="beer.onexone.beans.Person" lazy-init="true"  scope="prototype">
		<!-- 在bean里面 lazy-init="true" 开启懒加载 每个都需要设置 
		也可以配置beans标签设置全局懒加载
		-->
		<!-- 默认情况下都是单例模式 
		设置以下属性cope="prototype"可开启多例模式s
		-->
		</bean>	
	
		<!-- 可在bean中加上标签,可以调用初始化和销毁的方法 方法写到bean类中-->
	<bean id="personIni" class="beer.onexone.beans.Person"  init-method="" destroy-method="">
			<!-- init-method="" destroy-method=""
			初始化方法、销毁方法
			 -->
	</bean>
</beans>

七、基于注解模式的依赖注入

Spring整合Junit

import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

//整合SpringUnit
@RunWith(SpringJUnit4ClassRunner.class)
//配置文件
@ContextConfiguration(locations = {"classpath:applicationContext3.xml"})
public class SpringJunit1 {

}

1、先添加表头配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd ">

<!-- 开启注解 -->
<context:annotation-config></context:annotation-config>

</beans>

@Autowired 自动装载
写在属性上面 和set方法上
根据属性类型来查找对应的 在spring容器中 的类 找到该类 并且本来是唯一的
将该类注入到本来中
如果找到两个以上的类 抛异常
@Qualifier(value="p1") 强化Autowired 注解的 如果Autowired注解找到多个
在本注解中指定加载哪一个名字
只能使用本命字的类
如果没有 就抛异常

@Resource(name="p2") 上面两个注解的 组合 如果写名字 根据名字来找对应的类
如果不带name 属性 相当于Autowired

八、基于注解模式的依赖扫描

使用注解来配置JavaBean
xml配置需要扫描的包

可以在类上加注解
@Component           
@Controller        控制层使用
@Service      业务层 
@Repository    持久层
该四个注解都表示将本类加入到spring的容器中

案例:

XML

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-4.1.xsd 
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-4.1.xsd ">

	<!-- 开启注解 -->
	<context:annotation-config />
	<!-- 配置注解扫描的位置 -->
	<context:component-scan
		base-package="beer.onexone" />
	<!-- 配置数据库驱动 -->
	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName"
			value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql:///Spring?characterEncoding=utf8"></property>
		<property name="username" value="root"></property>
		<property name="password" value="Qwertyuiop852963"></property>
	</bean>

	<!-- 使用Spring数据库的支持类 -->
	<bean id="JdbcTemplate"
		class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

</beans>

view层

package beer.onexone.view;

import java.util.Date;
import java.util.List;

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 beer.onexone.beans.User;
import beer.onexone.service.SceanService;

//整合SpringUnit
@RunWith(SpringJUnit4ClassRunner.class)//配置文件
@ContextConfiguration(locations = {"classpath:applicationContextScean.xml"})
public class ScaenView {
		@Autowired
		SceanService sceanService;
		
		@Test
		public void add() throws Exception {
			User user = new User(55, "武则天", new Date());
			sceanService.add(user);
		}
		
		@Test
		public void update() throws Exception {
			User user = new User(88, "武则天", new Date());
			sceanService.update(user);
		}
		@Test
		public void query() throws Exception {
			List<User> query = sceanService.query();
			System.out.println(query);
		}
}

Service层

package beer.onexone.service;

import java.util.List;

import beer.onexone.beans.User;

public interface SceanService {
	void update(User user ) ;
	void add(User user ) ;
	List<User> query();
}
package beer.onexone.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import beer.onexone.beans.User;
import beer.onexone.dao.SceanDao;

//注解
@Service
public class SceanScrviceImpl implements SceanService {

	@Autowired
	SceanDao sceanDao;
	@Override
	public void update(User user) {
		sceanDao.update(user);
	}

	@Override
	public void add(User user) {
		sceanDao.add(user);
	}
	@Override
	public List<User> query(){
		return sceanDao.query();
	};
}

Dao层

package beer.onexone.dao;

import java.util.List;

import beer.onexone.beans.User;

public interface SceanDao {
			void add(User user);
			void update(User user ) ;
			List<User> query();
}
package beer.onexone.dao;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.ResultSetExtractor;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;
import org.springframework.test.context.jdbc.Sql;

import beer.onexone.beans.Person;
import beer.onexone.beans.User;

//注解
@Repository
public class SceanDaoImpl implements SceanDao {
	//导入Spring配置好的数据库连接
				@Autowired
				JdbcTemplate jdbcTemp;
				
				String sql;
				//修改数据库
				public void update(User user ) {
					sql = "update user set age=?,date=? where name =?";
					jdbcTemp.update(sql, user.getAge(),user.getDate(),user.getName());
				}
				
				//添加数据
				public void add(User user ) {
					sql = "insert into user (age,date,name) values(?,?,?)";
					jdbcTemp.update(sql, user.getAge(),user.getDate(),user.getName());
				}
				
				//查询数据
				public List<User> query() {
					sql="select * from user";
					return jdbcTemp.query(sql, new RowMapper<User>() {
						@Override
						public User mapRow(ResultSet arg0, int arg1) throws SQLException {
							 User user = new User(arg0.getInt("age"), arg0.getString("name"), arg0.getDate("date"));
							return user;
						}});
				}
}

jingsongchan

发表评论

电子邮件地址不会被公开。 必填项已用*标注