springsecurity注解 放行

**Spring框架的Bean管理注解方式的快速入门**
	
	1. 步骤一：下载Spring框架的开发包
		* 下载路径为：http://repo.spring.io/webapp/search/artifact/?0&q=spring-framework
		* 解压后的目录结构如下
			* docs			-- API和开发规范
			* libs			-- jar包和源码
				* Spring框架的jar包的特点是每个jar包都有3个（使用的jar包、文档的jar包和源代码的jar包）			
			* schema		-- 约束
	
	2. 步骤二：创建JavaWEB项目，引入Spring的开发包
		* 引入Spring框架IOC核心功能需要的具体的jar包
			* Spring框架的IOC的功能，那么根据Spring框架的体系结构图能看到，只需要引入如下的jar包
				* 在spring-framework-3.2.0.RELEASE/libs/下
					* Beans
					* Core
					* Context
					* Expression Language
			
			* Spring框架也需要引入日志相关的jar包
				* 在spring-framework-3.0.2.RELEASE-dependencies/org.apache.commons/com.springsource.org.apache.commons.logging/1.1.1
					* com.springsource.org.apache.commons.logging-1.1.1.jar
				
				* 还需要引入log4j的jar包 spring-framework-3.0.2.RELEASE-dependencies\org.apache.log4j\com.springsource.org.apache.log4j\1.2.15
					* com.springsource.org.apache.log4j-1.2.15.jar
	
	3. 步骤三：创建对应的包结构，编写Java的类，要注意：以后使用Spring框架做开发，都需要来编写接口与实现类！！
		* com.itcast.demo1
			* UserService			-- 接口
			* UserServiceImpl		-- 具体的实现类
	
	4. 步骤四：在src的目录下，创建applicationContext.xml的配置文件，然后引入约束。注意：因为现在想使用注解的方式，那么引入的约束发生了变化
		* 需要引入context的约束，具体的约束如下
			<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">
			
			</beans>
	
	5. 步骤五：在applicationContext.xml配置文件中开启组件扫描
		<!-- Spring的注解开发:组件扫描(类上注解: 可以直接使用属性注入的注解) -->
		<context:component-scan base-package="com.itheima.demo1"/>
		
		* 注意：可以采用如下配置
			<context:component-scan base-package="com.itheima"/> 这样是扫描com.itheima包下所有的内容
	
	6. 步骤六：在UserServiceImpl的实现类上添加注解
		* @Component(value="userService")	-- 相当于在XML的配置方式中 <bean id="userService" class="...">
	
	7. 步骤七：编写测试代码
		public class SpringDemo1 {
			@Test
			public void run1(){
				ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
				UserService us = (UserService) ac.getBean("userService");
				us.save();
			}
		}
	
	8. 步骤八：如果想注入属性
		@Value(value="美美")
		private String name;
		public void setName(String name) {
			this.name = name;
		}
	
----------
	
**Spring框架中Bean管理的常用注解**
	
	1. @Component:组件.(作用在类上)
	
	2. Spring中提供@Component的三个衍生注解:(功能目前来讲是一致的)
		* @Controller		-- 作用在WEB层
		* @Service			-- 作用在业务层
		* @Repository		-- 作用在持久层
		
		* 说明：这三个注解是为了让标注类本身的用途清晰，Spring在后续版本会对其增强
	
	3. 属性注入的注解(说明：使用注解注入的方式,可以不用提供set方法.)
		1. 如果是注入的普通类型，可以使用value注解
			* @value			-- 用于注入普通类型
		
		2. 如果注入的是对象类型，使用如下注解			
			* @Autowired		-- 自动装配
				* 注意：问题，默认按类型进行装配
				* 如果想按名称注入
				* @Qualifier	-- 强制使用名称注入
		
			* 具体的代码如下：ProductService的代码
				@Service(value="productService")
				public class ProductService {
					
					@Autowired	// 注入对象属性
					@Qualifier(value="productDao")	// 强制使用名称注入
					private ProductDao productDao;
					
					public void save(){
						// 调用dao层
						productDao.save();
					}
				}
			
			* ProductDao的代码如下		
				@Repository(value="productDao")
				public class ProductDao {
					public void save(){
						System.out.println("保存商品...");
					}
				}
		
		3. 刚才的上述两个注解一起使用，过于麻烦，所以提供了一个新的注解
			* @Resource		-- 相当于@Autowired和@Qualifier一起使用
			
			* 修改ProductService的代码如下
				@Service(value="productService")
				public class ProductService {
					
					@Resource(name="productDao")
					private ProductDao productDao;
					
					public void save(){
						// 调用dao层
						productDao.save();
					}
				}

OrderDao:

package demo1;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

@Repository(value="orderDao")
public class OrderDao {

	public void save(){
		System.out.println("保存订单");
	}
	
	//相当于配置init-method
	@PostConstruct
	public void init(){
		System.out.println("对象调用初始化方法");
	}
	
	//相当于配置destroy-method
	@PreDestroy
	public void des(){
		System.out.println("对象销毁了");
	}
}

OrderService:

package demo1;

public interface UserService {

	public  void sayHello();
}

OrderServiceImpl:

package demo1;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
/**
 * <bean id="userService" class="demo1.UserServiceImpl">
 * 		<property name="uname" value="美美"></property>
 * </bean>
 * 
 * @Component(value="userService")
 * @author mjl
 *
 */
/*@Component(value="userService")*/
@Service(value="userService")
public class UserServiceImpl implements UserService{

	//如果采用注解的方式，set方法可以省略不写了
	@Value(value="风车车")
	private String uname;	
	
	public void sayHello() {
		System.out.println("hello spring"+uname);
	}
	
	// 定义属性，提供set方法就OK了
	// @Autowired
	// @Qualifier(value="od")
	
	@Autowired
	private OrderDao orderDao;
	
	public void save(){
		// 创建持久层 OrderDao dao = new OrderDao();
		// dao.save();
		// 现在自己创建对象吗？Spring的IOC的容器创建！！
		
		orderDao.save();
	}
}

SpringDemo1:

package demo1;

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

public class SpringDemo1 {
 
	@Test
	public void run1(){
		
		ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
		UserServiceImpl usi=(UserServiceImpl) ac.getBean("userService");
		//usi.sayHello();
		usi.save();
	}
}

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

	<!-- Spring的注解开发:组件扫描(类上注解: 可以直接使用属性注入的注解) -->
	<context:component-scan base-package="demo1"/>
		
</beans>

 

注解+配置文件的方式：

ProductDao:

package demo2;

public class ProductDao {

	public void save(){
		System.out.println("保存商品");
	}
}

ProductService:

package demo2;

import javax.annotation.Resource;

public class ProductService {

	//提供持久层属性
	@Resource(name="productDao")
	private ProductDao productDao;
	
	public void save(){
		productDao.save();
	}
}

SpringDemo2:

package demo2;

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

import demo1.UserServiceImpl;

public class SpringDemo2 {

	@Test
	public void run1(){
		
		ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
		System.out.println(ac);
		ProductService ps= (ProductService) ac.getBean("productService");
		ps.save();
	}
}

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

	<!-- Spring的注解开发:组件扫描(类上注解: 可以直接使用属性注入的注解) -->
	<context:component-scan base-package="demo1"/>
		
	<!-- 创建Bean对象的时候，采用配置文件的方式 -->
	<bean id="productDao" class="demo2.ProductDao"/>
	<bean id="productService" class="demo2.ProductService"/>
	 
	<!-- 给对象的属性注入值时候，采用注解的方式 -->

</beans>

　　

spring的junit测试

Demo

//帮我们创建容器
@RunWith(SpringJUnit4ClassRunner.class) 
//指定创建容器时使用哪个配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo {
	
	//将名为user的对象注入到u变量中
	@Resource(name="user")
	private User u;
	
	@Test
	public void fun1(){
		System.out.println(u);
	}

}

User

@Component("user")
//等同于<bean name="user" class="cn.itcast.bean.User" />
//@Service("user")
//@Controller("user")
//@Repository("user")
//指定对象的作用域
//@Scope(scopeName="singleton|prototype")
@Scope(scopeName="singleton")
public class User {

	@Value("tom")
	private String name;
	private Integer age;
	//@Autowired
	//问题：如果匹配多个类型一致的对象，将无法选择具体注入哪一个对象
	//@Qualifier("car2") //使用@Qualifier注解告诉spring容器自动装配哪个名称的对象
	
	@Resource(name="car")
	private Car car;
	
	public Car getCar() {
		return car;
	}
	public void setCar(Car car) {
		this.car = car;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	
	@PostConstruct //在对象被创建后调用，init-method
	public void init(){
		System.out.println("我是初始化方法");
	}
	
	@PreDestroy //在对象销毁前调用，destroy-method
	public void destroy(){
		System.out.println("我是销毁方法");
	}
	
	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + ", car=" + car + "]";
	}
	
}

Car

@Component("car")
public class Car {

	@Value("玛莎拉蒂")
	private String name;
	@Value("呕吐绿")
	private String color;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	@Override
	public String toString() {
		return "Car [name=" + name + ", color=" + color + "]";
	}
	
}