Spring框架
Posted pere
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Spring框架相关的知识,希望对你有一定的参考价值。
L120102X1:创建工厂类
package interf;
public interface Animal {
public void eat();
public void sport();}
////
package model;
import interf.Animal;
public class Cat implements Animal {
public void eat() {
System.out.println("猫喜欢吃鱼");}
public void sport() {
System.out.println("猫很懒,不喜欢运动");}}
////
package model;
import interf.Animal;
public class Dog implements Animal {
public void eat() {
System.out.println("够喜欢吃肉");
}
public void sport() {
System.out.println("够喜欢运动");}}
////
package model;
import interf.Animal;
public class Factory {
public static final String CAT="cat";
public static final String DOG="dog";
public Animal getAnimal(String str){
if(CAT.equals(str)){
return new Cat();
}else if(DOG.equals(str)){
return new Dog();
}else{
return null;}}}
////
package factory;
import static org.junit.Assert.*;
import interf.Animal;
import model.Factory;
import org.junit.Test;
public class FactoryTest {
@Test
public void test() {
Factory factory=new Factory();
Animal animal=null;
animal=factory.getAnimal("cat");
animal.eat();
animal.sport();
animal=factory.getAnimal("dog");
animal.eat();
animal.sport();}} 2
L120103X1:
1、将Spring相关包导入项目
(1)素材中找到相关包,其明细如下
(2)将上述明细jar包复制到项目下面的lib中,如下:
(3)将lib下面的jar包全部选中—右键—Bulid Path—add,结果如下:
2、编写HelloSpring类,该类为Spring管理的对象
(1)在src下面新建cn.springdemo包,包里面新建HelloSpring类
(2)在HelloSpring类中编写一下代码:
package cn.springdemo;
public class HelloSpring {
//定义变量往后,它的值通过spring框架注入
private String who;
/**
* 定义打印方法,输出一句完整的问候
*/
public void print(){
System.out.println("Hello,"+this.getWho()+"!");
}
/**
* 获取who的值
* @return
*/
public String getWho() {
return who;
}
/**
* 设置who的值
* @param who
*/
public void setWho(String who) {
this.who = who;}}
3、定义配置文件来管理这个类的对象,进而进行对类的其他操作比如对who赋值
(1)工程下建立source Folder名字为resources
(2)将log4j.properties文件拷贝到resources文件里面,该文件是控制日志输出的
(3)在resources里面新建一个xml文件,名字为ApplicationContext
(4)打开ApplicationContext配置文件头,该文件头是固定的,拷贝进来即可
<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-3.2.xsd">
</beans>
(5)配置ApplicationContex文件中的完整配置
<?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-3.2.xsd">
<!-- bean元素声明spring创建的对象实例,id属性指定对象的唯一标识符,
方便程序的使用,class属性可以指定被声明的实例对应类 -->
<bean id="helloSpring" class="cn.springdemo.HelloSpring">
<!-- 指定被赋值的属性名 ,这里的who是和setWho对应的-->
<property name="who">
<value>Spring</value>
</property>
</bean>
</beans>
(6)在工程下建立source folder名字为test,在test下建立package名字为test,在这个test下建立一个JUnit test case名字为HelloSpringTest,在 HelloSpringTest中输入以下代码
package test;
import static org.junit.Assert.*;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.springdemo.HelloSpring;
public class HelloSpringTest {
@Test
public void test() {
//ClassPathXmlApplicationContext读取配置文件
ApplicationContext context=
new ClassPathXmlApplicationContext("ApplicationContext.xml");
HelloSpring helloSpring=(HelloSpring)context.getBean("helloSpring");
helloSpring.print();
}}
结果为:Hello,Spring! 3
L120104X1:
实现动态组装的打印机,灵活选择墨盒和纸张大小
1、创建WEB项目工程,名字为Printer,将相关的spring的jar包复制在bin下,在选中拷贝在bin下面的所有包右键-build path-add to build path将其加入referenced libraries中
2、新建source folder用于存放配置文件,首先将log4j.properties拷贝到里面
3、Src下面创建一个package,名字为cn.printer,用于存放接口
4、在cn.printer里面新建一个接口Ink.java里面的代码如下
package cn.printer;
//墨盒接口
public interface Ink {
//定义打印机采用的颜色值,r-红色,g-绿色,b-蓝色
public String getColor(int r,int g,int b);
}
5、在cn.printer里面新建另一个接口Paper.java里面的代码如下
package cn.printer;
//打印采用的纸张接口
public interface Paper {
//定义常量,用于换行
public static final String newLine=" ";
//往纸张里面逐个字符输出内容
public void putInChar(char c);
//得到输出到纸张中的内容
public String getContent();
}
6、在src下面新建一个包,名字为cn.ink,用于实现墨盒接口
7、在cn.ink里面新建GreyInk.java用于实现ink接口实现黑白打印
package cn.ink;
import java.awt.Color;
import cn.printer.Ink;
//灰色墨盒,实现ink接口
public class GreyInk implements Ink {
//定义打印采用灰色
public String getColor(int r, int g, int b) {
int c=(r+g+b)/3;
Color color=new Color(c,c,c);
return "#"+Integer.toHexString(color.getRGB()).substring(2);
}
}
8、在cn.ink里面新建ColorInk.java用于实现ink接口实现彩色打印
package cn.ink;
import java.awt.Color;
import cn.printer.Ink;
//彩色墨盒,实现Ink接口
public class ColorInk implements Ink {
//打印采用彩色
public String getColor(int r, int g, int b) {
Color color=new Color(r,g,b);
return "#"+Integer.toHexString(color.getRGB()).substring(2);
}
}
9、在cn.ink里面新建TextPaper.java用于实现ink接口实现paper接口
package cn.ink;
import java.awt.print.Pageable;
import cn.printer.Paper;
public class TextPaper implements Paper {
//每一行能输入的字符数
private int charPerLine=16;
//每页的行数
private int linePerPage=8;
//当前的横向位置,从0到charPerLine-1
private int posx=0;
//当前行号
private int posy=0;
//当前页号
private int posp=1;
//纸张中的内容
private String content="";
public void putInChar(char c) {
content +=c;
++posx;
//判断是否换行
if(posx==charPerLine){
content +=Paper.newLine;
posx=0;
++posy;
}
//判断是否换页
if(posy==linePerPage){
content +="==第"+posp+"页==";
content +=Paper.newLine+Paper.newLine;
posy=0;
++posy;
}
}
public String getContent() {
String ret=content;
if(!(posx==0&&posy==0)){
int count=linePerPage-posy;
for(int i=0;i<count;i++){
ret+=Paper.newLine;
}
ret+="==第"+posp+"页==";
}
return ret;
}
//设值注入所需要的Setter方法,注入charperLine的值,只有设值了这个方法Spring才能往里面注入值
public void setCharPerLine(int charPerLine) {
this.charPerLine = charPerLine;
}
//设值注入所需要的Setter方法,注入linePerPage的值,只有设值了这个方法Spring才能往里面注入值
public void setLinePerPage(int linePerPage) {
this.linePerPage = linePerPage;}}
10、在cn.printer里面新建一个类名字为Printer,里面输入以下代码,实现打印内容输出
package cn.printer;
//打印机类
public class Printer {
//面向接口编程,定义ink接口变量
private Ink ink;
//面向接口编程,定义paper接口变量
private Paper paper;
//提供Ink的setter方法,以进行设值注入
public void setInk(Ink ink) {
this.ink = ink;
}
//提供Paper的setter方法,以进行设值注入
public void setPaper(Paper paper) {
this.paper = paper;
}
//打印方法,查看打印采用的颜色和纸张中打印的内容
public void print(String str){
System.out.println("使用"+ink.getColor(225, 200, 0)+"颜色打印 ");
for(int i=0;i<str.length();i++){
paper.putInChar(str.charAt(i));
}
System.out.println(paper.getContent());
}
}
11、在resorces下建立ApplicationContext配置文件,在配置文件中配置如下代码
<?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-3.2.xsd">
<!-- 指定灰色墨盒的bean元素,该元素的id为greyInk,class属性指定要实例化的类 -->
<bean id="greyInk" class="cn.ink.GreyInk"></bean>
<!-- 指定彩色墨盒的bean元素,该元素的id为colorInk,class属性指定要实例化的类 -->
<bean id="colorInk" class="cn.ink.ColorInkk"></bean>
<!-- 指定a4paper的bean元素,该元素的id为a4paper,class属性指定要实例化的类 -->
<bean id="a4paper" class="cn.ink.TextPaper">
<!-- property元素指定需要赋值的属性,charPerLine需要赋值,
TextPaper类需要写一个setcharPerLine(),进行设值注入-->
<property name="charPerLine" value="8"/>
<!-- property元素指定需要赋值的属性,charPerLine需要赋值,
TextPaper类需要写一个setlinePerpage(),进行设值注入-->
<property name="linePerpage" value="6"/>
</bean>
<bean id="b5paper" class="cn.ink.TextPaper">
<!-- property元素指定需要赋值的属性,charPerLine需要赋值,
TextPaper类需要写一个setcharPerLine(),进行设值注入-->
<property name="charPerLine" value="6"/>
<!-- property元素指定需要赋值的属性,charPerLine需要赋值,
TextPaper类需要写一个setlinePerpage(),进行设值注入-->
<property name="linePerpage" value="5"/>
</bean>
<!-- 指定打印机的bean元素,该元素的id为printer,class属性指定要实例化的类 -->
<bean id="printer" class="cn.printer。Printer">
<!-- property元素指定需要赋值的属性,ink需要赋值,
Printer类需要写一个setInk(),进行设值注入-->
<property name="ink" ref="greyInk"/>
<!-- property元素指定需要赋值的属性,paper需要赋值,
Printer类需要写一个setpaper(),进行设值注入-->
<property name="paper" ref="a4paper"/>
</bean>
</beans>
12、在工程下建立source folder名字为test,在test下建立package名字为test,在这个test下建立一个JUnit test case名字为PrinterTest,在里面中输入以下代码
package cn.test;
import static org.junit.Assert.*;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.printer.Printer;
public class PrinterTest {
@Test
public void test() {
ApplicationContext context=new
ClassPathXmlApplicationContext("ApplicationContext.xml");
Printer printer=(Printer)context.getBean("printer");
String content="几位轻量级容器的作者曾骄傲地对我说:这些容器非常有"
+ "用,因为它们实现了“控制反转”。这样的说辞让我深感迷惑:控"
+ "制反转是框架所共有的特征,如果仅仅因为使用了控制反转就认为"
+ "这些轻量级容器与众不同,就好像在说“我的轿车是与众不同的," + "因为它有4个轮子。";
printer.print(content); }}
运行结果为:
L120108X1
实现aop操作
1、在下面web项目的基础上进行测试
(1)user类代码
package entity;
// 用户实体类
public class User {
private Integer id;// 用户ID
private String username;// 用户名
private String password;// 密码
private String email;// 电子邮件
// getter & setter
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
(2)UserDao代码
package dao;
import entity.User;
//增加DAO接口,定义了所需的持久化方法
public interface UserDao {
public void save(User user);
}
(3)UserDaoImpl代码
package dao.impl;
import dao.UserDao;
import entity.User;
//用户DAO类,实现IDao接口,负责User类的持久化操作
public class UserDaoImpl implements UserDao {
public void save(User user) {
// 这里并未实现完整的数据库操作,仅为说明问题
System.out.println("保存用户信息到数据库");
}
}
(4)UserService代码
package service;
import entity.User;
//用户业务接口,定义了所需的业务方法
public interface UserService {
public void addNewUser(User user);
}
(5)UserServiceImpl代码
package service.impl;
import dao.UserDao;
import entity.User;
import service.UserService;
//用户业务类,实现对User功能的业务管理
public class UserServiceImpl implements UserService {
//声明接口类型的引用,和具体实现类解耦合
private UserDao dao;
//dao 属性的setter访问器,会被Spring调用,实现设值注入
public void setDao(UserDao dao) {
this.dao=dao;
}
public void addNewUser(User user) {
//调用用户DAO的方法保存用户信息
dao.save(user);
}
}
2、引入jar包
(1)引入Spring基础jar包
(2)引入AOP专用jar包,并进行build path
(3)引入log4j.properties
新建source folder,名字为resources,将入log4j.properties拷贝在里面来
3、在src下面建立packeage名字为aop,在aop中创建UserSercviceLogger类,类代码为:
package aop;
import java.util.Arrays;
import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
//增强处理类
public class UserSercviceLogger {
private static Logger log=Logger.getLogger(UserSercviceLogger.class);
public void before(JoinPoint jp){//Joinpoint用来获取目标对象的信息
//前置增强处理,getTarget()获取目标对象,哪个类,getSignature()哪个方法,getArgs()参数,是一个数组
log.info("调用"+jp.getTarget()+"的"+jp.getSignature()
+"方法,方法参数"+Arrays.toString(jp.getArgs()));
}
public void afterReturning(JoinPoint jp,Object result){
log.info("调用"+jp.getTarget()+"的"+jp.getSignature()
+"方法,方法参数"+result);
}}
4、配置配置文件
<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">
<!-- 存在调用关系的类声明他们的bean元素 -->
<bean id="userDao" class="dao.impl.UserDaoImpl"></bean>
<bean id="userServiceImpl" class="service.impl.UserServiceImpl">
<property name="dao" ref="userDao"/>
</bean>
<!-- 声明增强类的bean元素 -->
<bean id="theLogger" class="aop.UserSercviceLogger"></bean>
<!-- <aop:config>是最外层标签,所有的aop配置都需在里面进行 -->
<aop:config>
<!-- 切入点,id为名字可以随便取,但上下文一致,expression为表达式-->
<aop:pointcut id="pointcut" expression=
"execution(public void addNewUser(entity.User))"/>
<!--织入增强处理, 引入切入点,定义切面 ref用谁来增强-->
<aop:aspect ref="theLogger">
<!-- 设置前置增强,method的名字before可以随便取,但是要和
UserSercviceLogger.java中的一致 并不是与标签一致,pointcut-ref寻找切入点值为pointcut-->
<aop:before method="before" pointcut-ref="pointcut"/>
<!-- 设置后置增强,引入切入点,注入目标方法的返回值result-->
<aop:after-returning method="afterReturning"
pointcut-ref="pointcut" returning="result"/>
</aop:aspect>
</aop:config>
</beans>
5、创建测试类AopTest,代码如下
package test;
import static org.junit.Assert.*;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import entity.User;
import service.UserService;
public class AopTest {
@Test
public void test() {
ApplicationContext context=new ClassPathXmlApplicationContext("ApplicationContext.xml");
UserService userService=(UserService)context.getBean("userService");
User user=new User();
user.setId(1);
user.setUsername("test");
user.setPassword("111");
user.setEmail("test@163.com");
userService.addNewUser(user);
}
}
结果如下:
[INFO] 2019-10-14 23:40:58,896 aop.UserSercviceLogger - 调用service.impl.UserServiceImpl@44a28a5b的void service.UserService.addNewUser(User)方法,方法参数[entity.User@29f7831]
保存用户信息到数据库
[DEBUG] 2019-10-14 23:40:58,897 org.springframework.beans.factory.support.DefaultListableBeanFactory - Returning cached instance of singleton bean ‘theLogger‘
[INFO] 2019-10-14 23:40:58,897 aop.UserSercviceLogger - 调用service.impl.UserServiceImpl@44a28a5b的void service.UserService.addNewUser(User)方法,方法参数null
以上是关于Spring框架的主要内容,如果未能解决你的问题,请参考以下文章