Spring框架

时间：2019-10-15 12:53:41 阅读：94 评论：0 收藏：0 [点我收藏+]

标签：ring res com The ret mamicode cached deb tmp

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属性可以指定被声明的实例对应类 -->

<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="\r\n";

//往纸张里面逐个字符输出内容

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)+"颜色打印\n");

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

<!-- property元素指定需要赋值的属性，charPerLine需要赋值，

TextPaper类需要写一个setcharPerLine（），进行设值注入-->

<!-- property元素指定需要赋值的属性，charPerLine需要赋值，

TextPaper类需要写一个setlinePerpage（），进行设值注入-->

</bean>

<!-- property元素指定需要赋值的属性，charPerLine需要赋值，

TextPaper类需要写一个setcharPerLine（），进行设值注入-->

<!-- property元素指定需要赋值的属性，charPerLine需要赋值，

TextPaper类需要写一个setlinePerpage（），进行设值注入-->

</bean>

<!-- property元素指定需要赋值的属性，ink需要赋值，

Printer类需要写一个setInk（），进行设值注入-->

<!-- property元素指定需要赋值的属性，paper需要赋值，

Printer类需要写一个setpaper（），进行设值注入-->

</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); }}

运行结果为：

改b5 4-5

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>

<aop:config>

<aop:pointcut id="pointcut" expression=

"execution(public void addNewUser(entity.User))"/>

<aop:aspect ref="theLogger">

<!-- 设置前置增强，method的名字before可以随便取，但是要和

UserSercviceLogger.java中的一致并不是与标签一致,pointcut-ref寻找切入点值为pointcut-->

<aop:before method="before" pointcut-ref="pointcut"/>

<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框架

标签：ring res com The ret mamicode cached deb tmp

原文地址：https://www.cnblogs.com/pere/p/11676946.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行