java spring文档 java spring 教程

转载

jacksky 2023-09-19 01:11:13

文章标签 java spring文档 Java Spring spring java 文章分类 Java 后端开发

文章目录

Spring简介

开始我们的程序

IOC简介
程序入门（对象注入）
对象包含其他对象
使用注解来注入对象

AOP简介
AOP程序
通过注解的方式

注释方式测试

junit 测试框架简介
简单例子

参考

Spring简介

开始我们的程序

按照网上相关的教程，我们找到了一份可以立即运行的Spring，这样减少了前期繁琐的配置，可以更快地进入我们的学习之中去。

这里推荐一个网站：

可以在本文参考处找到网址，结合Spring官方文档可以快速上手。

java spring文档 java spring 教程_Java

IOC

IOC简介

程序入门（对象注入）

简单来说，就写一个简单的pojo 的java类：

package com.how2java.pojo;
 
public class Category {
 
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    private int id;
    private String name;
}

下面是简单的配置文件：
其中，给Category类注入了一个c对象，并给其name属性赋值。

<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
   http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx 
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/context      
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 	
    <bean name="c" class="com.how2java.pojo.Category">
        <property name="name" value="category 1" />
    </bean>
</beans>

最后是一个简单的测试文件：
在其中，我们从容器中获取了Category c，然后打印了它的名字。

package com.how2java.test;

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

import com.how2java.pojo.Category;
import com.how2java.pojo.Product;

public class TestSpring {

	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "applicationContext.xml" });

		Category c = (Category) context.getBean("c");
		System.out.println(c.getName());
	}
}

然后可以看到输出：

java spring文档 java spring 教程_Java_02

对象包含其他对象

我们在下面构造一个java pojo类，Product。
Product中包含了一个Category类的对象。

package com.how2java.pojo;

public class Product {

	private int id;
	private String name;
	private Category category;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Category getCategory() {
		return category;
	}
	public void setCategory(Category category) {
		this.category = category;
	}
}

那么继续的，在配置文件中如下注入一个Product类的对象p：

<bean name="p" class="com.how2java.pojo.Product">
        <property name="name" value="product1" />
        <!-- <property name="category" ref="c" /> -->
    </bean>

使用注解来注入对象

首先，在注入对象的地方添加一句：<context:annotation-config/> 然后，我们下面将使用注解的方法来实现自动注入。

<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
   http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx 
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/context      
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 	
 	<context:annotation-config/>
    <bean name="c" class="com.how2java.pojo.Category">
        <property name="name" value="category 1" />
    </bean>
 	<bean name="p" class="com.how2java.pojo.Product">
        <property name="name" value="product1" />
        <!-- <property name="category" ref="c" /> -->
    </bean>
</beans>

方法1：在声明处添加注解

@Autowired
private Category category;

方法2：在set修改处实现注解

@Autowired
public void setCategory(Category category)

上面是自动注入的方法。
如果你想特指一个Category，那么可以使用方法3。

方法3：使用@Rescource

@Resource(name="c")
private Category category;

下面讲对于Beans的注解。
其中，我们删除了原来的注入对象的代码，然后添加
<context:component-scan base-package="com.how2java.pojo"/> 他告诉Srping，Bean中相关的Java类都放在pojo这个包中。

<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
   http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx 
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/context      
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 	
 	  <context:component-scan base-package="com.how2java.pojo"/>
</beans>

然后分别将我们的Product类，和Category分别注解为
@Component("p") 和 @Component("c") 然后给他们的name添加一个默认值。

然后运行代码，然后可以看到下面的结果：

java spring文档 java spring 教程_java spring文档_03

AOP

AOP简介

AOP就是面向切面编程，这是一种编程思想。
主要就是说，一个系统可能有很多核心功能，辅助功能。
就像登陆、注销、添加等等这样即是核心功能。
那么其他例如，功能的运行时间统计，相关的日志记录之类的东西，便是所谓辅助功能呢。
简单来说，AOP就是通过解耦的方法让核心功能能够方便地使用嵌入这些辅助功能。

AOP程序

首先，我们需要编写一个核心功能，即如下的Service：

package com.how2java.service;

public class ProductService {
	
	
	public void doSomeService(){

		System.out.println("doSomeService");
		
	}
	
	
}

下面编写辅助功能，即一个简单LoggerAspect 日志记录切面：
其中，包含log方法。log方法会在切点前打印一句log和切点后打印一句log。

package com.how2java.aspect;
import org.aspectj.lang.ProceedingJoinPoint;

public class LoggerAspect { 

	public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
		System.out.println("start log:" + joinPoint.getSignature().getName());
		Object object = joinPoint.proceed();
		System.out.println("end log:" + joinPoint.getSignature().getName());
		return object;
	}
}

接下来，首先注入我们的Service对象s：

<bean name="s" class="com.how2java.service.ProductService">

接下来，注入我们的LoggerAspect的对象loggerAspect:

<bean id="loggerAspect" class="com.how2java.aspect.LoggerAspect"/>
    
	<aop:config>
	
		<aop:pointcut id="loggerCutpoint" 
			expression=
			"execution(* com.how2java.service.ProductService.*(..))"/>
			
		<aop:aspect id="logAspect" ref="loggerAspect">
			<aop:around pointcut-ref="loggerCutpoint" method="log"/>
		</aop:aspect>
	</aop:config>

下面，是Service的执行环境，即Service.*表示所有方法，(..)表示所有任意数量和类型的参数

<aop:pointcut id="loggerCutpoint" 
			expression=
			"execution(* com.how2java.service.ProductService.*(..))"/>

下面，当我们在上面切点触发的时候，调用以下的切面类的log方法。

<aop:aspect id="logAspect" ref="loggerAspect">
			<aop:around pointcut-ref="loggerCutpoint" method="log"/>
		</aop:aspect>

运行后，我们可以看到：

java spring文档 java spring 教程_java_04

通过注解的方式

首先将我们的Service 标记为Component组件，就如之前一样。

接着，我们标记LoggerAspect日志切面，首先是一个组件，他会加入到Bean中，其次它是一个Aspect切面。

@Aspect
@Component

通过使用@Around(value="xxx")来指示说这个切面被调用去修饰的情况。

@Around(value = "execution(* com.how2java.service.ProductService.*(..))")
	public Object log(ProceedingJoinPoint joinPoint) throws Throwable {

最后就是xml文件的配置了：
我们只需要在beans中，引入两个查找组件包的名字。
还有让它自动配置aspect。

<context:component-scan base-package="com.how2java.aspect"/>
  <context:component-scan base-package="com.how2java.service"/>
  <aop:aspectj-autoproxy/>

注释方式测试

junit 测试框架简介

简单例子

在Spring中，可以使用junit来进行测试。

下面是一个简单junit的代码：

package com.how2java.test;
 
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.how2java.pojo.Category;
 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestSpring {
    @Autowired
    Category c;
 
    @Test
    public void test(){
        System.out.println(c.getName());
    }
}

传统使用main的测试代码：

package com.how2java.test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.how2java.pojo.Category;

public class TestSpringOldWay {

	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "applicationContext.xml" });

		Category c = (Category) context.getBean("c");

		System.out.println(c.getName());
	}
}