package com.service;

import java.util.List;
import com.domain.Book;

public interface BookService {
    /**
     * 查找所有的图书.
     * 
     * @return Book对象的List集合.
     */
    List<Book> getAllBooks();
}

package com.service;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.domain.Book;
import com.mapper.BookMapper;

/**
 * Book服务层接口实现类.
 */
// @Service("bookService")注解高数Spring创建当前类的一个名为bookService的bean.
@Service("bookService")
public class BookServiceImpl implements BookService {
    /**
     * 自动注入BookMapper.
     */
    @Autowired
    private BookMapper bookMapper;

    /**
     * BookService接口的getAllBooks()方法的实现.
     * 
     * @see{BookService}
     */
    @Override
    public List<Book> getAllBooks() {
        return bookMapper.selectAllBooks();
    }
}

package com.service;

import com.domain.User;

public interface UserService {
    /**
     * 判断用户登录.
     * 
     * @param loginname
     * @param password
     * @return 找到用户则返回User对象,找不到返回null
     */
    User login(String loginname, String password);
}

package com.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.domain.User;
/**
 * User服务层接口实现.
 */
// @Service("userService")表示当前类作为Spring的一个bean,名为userService
import com.mapper.UserMapper;

@Service("userService")
public class UserServiceImpl implements UserService {
    /**
     * 自动注入UserMapper
     */
    @Autowired
    private UserMapper userMapper;

    /**
     * UserServiec接口的login方法实现.
     * 
     * @see{UserService}
     */
    @Override
    public User login(String loginname, String password) {
        return userMapper.selectUserByLoginnamePassword(loginname, password);
    }
}

package com.domain;
public class User {
    private Integer id;
    private String loginname;
    private String password;
    private String username;
    private String phone;
    private String address;
    public User() {
    }
    // 此处省略getter和setter方法,请自己补上
    @Override
    public String toString() {
        return "User [id=" + id + ", loginname=" + loginname + ", password=" + password + ", username=" + username
                + ", phone=" + phone + ", address=" + address + "]";
    }
}

package com.domain;
import java.util.Date;
public class Book {
    // id
    private Integer id;
    // 书名
    private String name;
    // 作者
    private String author;
    // 出版日期
    private Date publicationdate;
    // 出版社
    private String publication;
    // 价格
    private Double price;
    // 封面图片
    private String image;
    // 详细描述
    private String remark;
    public Book() {
    }
    // 此处省略getter和setter方法,请自己补上
    @Override
    public String toString() {
        return "Book [id=" + id + ", name=" + name + ", author=" + author + ", publicationdate=" + publicationdate
                + ", publication=" + publication + ", price=" + price + ", image=" + image + ", remark=" + remark + "]";
    }
}

package com.mapper;

import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import com.domain.User;

public interface UserMapper {
    @Select("select * from tb_user where loginname=#{loginname} and password=#{password}")
    User selectUserByLoginnamePassword(@Param("loginname") String loginname, @Param("password") String password);
}

package com.mapper;

import java.util.List;
import org.apache.ibatis.annotations.Select;
import com.domain.Book;

public interface BookMapper {
    @Select("select * from tb_book")
    List<Book> selectAllBooks();
}

public class ProcessArray
{
    // 定义一个each()方法，用于处理数组，
    public void each(int[] target, Command cmd)
    {
        cmd.process(target);
    }
}

public interface Command
{
    // 接口里定义的process()方法用于封装“处理行为”
    void process(int[] target);
}

public class CommandTest
{
    public static void main(String[] args)
    {
        ProcessArray pa = new ProcessArray();
        int[] target ={3, -4, 6, 4};
        // 第一次处理数组，具体处理行为取决于Command对象
        pa.each(target, new Command()
        {
            // 重写process()方法，决定具体的处理行为
            public void process(int[] target)
            {
                for (int tmp : target)
                {
                    System.out.println("迭代输出目标数组的元素:" + tmp);
                }
            }
        });
        System.out.println("------------------");
        // 第二次处理数组，具体处理行为取决于Command对象
        pa.each(target, new Command()
        {
            // 重写process()方法，决定具体的处理行为
            public void process(int[] target)
            {
                int sum = 0;
                for (int tmp : target)
                {
                    sum += tmp;
                }
                System.out.println("数组元素的总和是:" + sum);
            }
        });
    }
}

public class LambdaTest
{
    public static void main(String[] args)
    {
        ProcessArray pa = new ProcessArray();
        int[] target ={3, -4, 6, 4};
        // 第一次处理数组，具体处理行为取决于Lambda表达式
        pa.each(target, array ->
        {
            for (int tmp : array)
            {
                System.out.println("迭代输出目标数组的元素:" + tmp);
            }
        });
        System.out.println("------------------");
        // 第二次处理数组，具体处理行为取决于Lambda表达式
        pa.each(target, array ->
        {
            int sum = 0;
            for (int tmp : array)
            {
                sum += tmp;
            }
            System.out.println("数组元素的总和是:" + sum);
        });
    }
}

// 定义一个`HibernateCallback`接口,该接口封装持久化处理行为
public interface HibernateCallback
{
    Object doInHibernate(Session session);
}

List list=getHibernateTemplate()
    .execute(session ->{
        //执行 Hibernate分页查询
        List result=session.createQuery(hql)
            .setFirstResult(offset);
            .setMaxResults(pageSize);
            .list();
            return result;
    });
return list;

public class Computer
{
    private Output out;

    public Computer(Output out)
    {
        this.out = out;
    }
    // 定义一个模拟获取字符串输入的方法
    public void keyIn(String msg)
    {
        out.getData(msg);
    }
    // 定义一个模拟打印的方法
    public void print()
    {
        out.out();
    }
    public static void main(String[] args)
    {
        // 创建OutputFactory
        OutputFactory of = new OutputFactory();
        // 将Output对象传入，创建Computer对象
        Computer c = new Computer(of.getOutput());
        c.keyIn("轻量级Java EE企业应用实战");
        c.keyIn("疯狂Java讲义");
        c.print();
    }
}

public class OutputFactory
{
    public Output getOutput()
    {
        return new Printer();
    }
}

// 让Printer类实现Output
public class Printer implements Output
{
    private String[] printData = new String[MAX_CACHE_LINE];
    // 用以记录当前需打印的作业数
    private int dataNum = 0;
    public void out()
    {
        // 只要还有作业，继续打印
        while(dataNum > 0)
        {
            System.out.println("打印机打印：" + printData[0]);
            // 把作业队列整体前移一位，并将剩下的作业数减1
            System.arraycopy(printData , 1, printData, 0, --dataNum);
        }
    }
    public void getData(String msg)
    {
        if (dataNum >= MAX_CACHE_LINE)
        {
            System.out.println("输出队列已满，添加失败");
        }
        else
        {
            // 把打印数据添加到队列里，已保存数据的数量加1。
            printData[dataNum++] = msg;
        }
    }
}

public class BetterPrinter implements Output
{
    private String[] printData = new String[MAX_CACHE_LINE * 2];
    // 用以记录当前需打印的作业数
    private int dataNum = 0;
    public void out()
    {
        // 只要还有作业，继续打印
        while(dataNum > 0)
        {
            System.out.println("高速打印机正在打印：" + printData[0]);
            // 把作业队列整体前移一位，并将剩下的作业数减1
            System.arraycopy(printData , 1, printData, 0, --dataNum);
        }
    }
    public void getData(String msg)
    {
        if (dataNum >= MAX_CACHE_LINE * 2)
        {
            System.out.println("输出队列已满，添加失败");
        }
        else
        {
            // 把打印数据添加到队列里，已保存数据的数量加1。
            printData[dataNum++] = msg;
        }
    }
}

public class OutputFactory
{
    public Output getOutput()
    {
        return new BetterPrinter();
    }
}

package org.crazyit.ioc;

public interface ApplicationContext
{
    // 获取指定Bean实例的方法
    Object getBean(String name) throws Exception;
}

package org.crazyit.ioc;

import java.lang.reflect.*;
import java.util.*;
import java.io.*;
import org.dom4j.*;
import org.dom4j.io.*;

public class CrazyitXmlApplicationContext implements ApplicationContext
{
    // 保存容器中所有单例模式的Bean实例
    private Map<String, Object> objPool = Collections
            .synchronizedMap(new HashMap<String, Object>());
    // 保存配置文件对应的Document对象
    private Document doc;
    // 保存配置文件里的根元素
    private Element root;
    public CrazyitXmlApplicationContext(String filePath) throws Exception
    {
        SAXReader reader = new SAXReader();
        doc = reader.read(new File(filePath));
        root = doc.getRootElement();
        initPool();
        initProp();
    }

    public Object getBean(String name) throws Exception
    {
        Object target = objPool.get(name);
        // 对于singleton Bean，容器已经初始化了所有Bean实例，直接返回即可
        if (target.getClass() != String.class)
        {
            return target;
        } else
        {
            String clazz = (String) target;
            // 对于prototype对象并未注入属性值
            return Class.forName(clazz).getConstructor().newInstance();
        }
    }
    // 初始化容器中所有singleton Bean
    private void initPool() throws Exception
    {
        // 遍历配置文件里的每个<bean.../>元素
        for (Object obj : root.elements())
        {
            Element beanEle = (Element) obj;
            // 取得<bean.../>元素的id属性
            String beanId = beanEle.attributeValue("id");
            // 取得<bean.../>元素的class属性
            String beanClazz = beanEle.attributeValue("class");
            // 取得<bean.../>元素的scope属性
            String beanScope = beanEle.attributeValue("scope");
            // 如果<bean.../>元素的scope属性不存在，或为singleton
            if (beanScope == null || beanScope.equals("singleton"))
            {
                // 以默认构造器创建Bean实例，并将其放入objPool中
                objPool.put(beanId, Class.forName(beanClazz).getConstructor()
                        .newInstance());
            } else
            {
                // 对于非singlton Bean，存放该Bean实现类的类名。
                objPool.put(beanId, beanClazz);
            }
        }
    }
    // 初始化容器中singleton Bean的属性
    private void initProp() throws Exception
    {
        // 遍历配置文件里的每个<bean.../>元素
        for (Object obj : root.elements())
        {
            Element beanEle = (Element) obj;
            // 取得<bean.../>元素的id属性
            String beanId = beanEle.attributeValue("id");
            // 取得<bean.../>元素的scope属性
            String beanScope = beanEle.attributeValue("scope");
            // 如果<bean.../>元素的scope属性不存在，或为singleton
            if (beanScope == null || beanScope.equals("singleton"))
            {
                // 取出objPool的指定的Bean实例
                Object bean = objPool.get(beanId);
                // 遍历<bean.../>元素的每个<property.../>子元素
                for (Object prop : beanEle.elements())
                {
                    Element propEle = (Element) prop;
                    // 取得<property.../>元素的name属性
                    String propName = propEle.attributeValue("name");
                    // 取得<property.../>元素的value属性
                    String propValue = propEle.attributeValue("value");
                    // 取得<property.../>元素的ref属性
                    String propRef = propEle.attributeValue("ref");
                    // 将属性名的首字母大写
                    String propNameCamelize = propName.substring(0, 1)
                            .toUpperCase()
                            + propName.substring(1, propName.length());
                    // 如果<property.../>元素的value属性值存在
                    if (propValue != null && propValue.length() > 0)
                    {
                        // 获取设值注入所需的setter方法
                        Method setter = bean.getClass().getMethod(
                                "set" + propNameCamelize, String.class);
                        // 执行setter注入
                        setter.invoke(bean, propValue);
                    }
                    if (propRef != null && propRef.length() > 0)
                    {
                        // 取得需要被依赖注入的Bean实例
                        Object target = objPool.get(propRef);
                        // objPool池中不存在指定Bean实例
                        if (target == null)
                        {
                            // 此处还应处理Singleton Bean依赖prototype Bean的情形
                        }
                        // 定义设值注入所需的setter方法
                        Method setter = null;
                        // 遍历target对象所所实现的所有接口
                        for (Class<?> superInterface : target.getClass()
                                .getInterfaces())
                        {
                            try
                            {
                                // 获取设值注入所需的setter方法
                                setter = bean.getClass().getMethod(
                                        "set" + propNameCamelize,
                                        superInterface);
                                // 如果成功取得该接口对应的方法，直接跳出循环
                                break;
                            } catch (NoSuchMethodException ex)
                            {
                                // 如果没有找到对应的setter方法，继续下次循环
                                continue;
                            }
                        }
                        // 如果setter方法依然为null，
                        // 则直接取得target实现类对应的setter方法
                        if (setter == null)
                        {
                            setter = bean.getClass().getMethod(
                                    "set" + propNameCamelize,
                                    target.getClass());
                        }
                        // 执行setter注入
                        setter.invoke(bean, target);
                    }
                }
            }
        }
    }
}

package lee;

import org.crazyit.ioc.*;

public class IoCTest
{
    public static void main(String[] args) throws Exception
    {
        // 创建IoC容器
        ApplicationContext ctx = new CrazyitXmlApplicationContext("beans.xml");
        // 从IoC容器中取出computer Bean
        Computer c = (Computer) ctx.getBean("computer");
        // 测试Computer对象
        c.keyIn("轻量级Java EE企业应用实战");
        c.keyIn("疯狂Java讲义");
        c.print();
        System.out.println(ctx.getBean("now"));
    }
}

public interface Image
{
    void show();
}

// 使用该BigImage模拟一个很大图片
public class BigImage implements Image
{
    public BigImage()
    {
        try
        {
            // 程序暂停3s模式模拟系统开销
            Thread.sleep(3000);
            System.out.println("图片装载成功...");
        } catch (InterruptedException ex)
        {
            ex.printStackTrace();
        }
    }
    // 实现Image里的show()方法
    public void show()
    {
        System.out.println("绘制实际的大图片");
    }
}

public class ImageProxy implements Image
{
    // 组合一个image实例，作为被代理的对象
    private Image image;
    // 使用抽象实体来初始化代理对象
    public ImageProxy(Image image)
    {
        this.image = image;
    }
    /**
     * 重写Image接口的show()方法 该方法用于控制对被代理对象的访问，
     * 并根据需要负责创建和删除被代理对象
     */
    public void show()
    {
        // 只有当真正需要调用image的show方法时才创建被代理对象
        if (image == null)
        {
            image = new BigImage();
        }
        image.show();
    }
}

public class BigImageTest
{
    public static void main(String[] args)
    {
        long start = System.currentTimeMillis();
        // 程序返回一个Image对象，该对象只是BigImage的代理对象
        Image image = new ImageProxy(null);
        System.out.println(
                "系统得到Image对象的时间开销:" + (System.currentTimeMillis() - start));
        // 只有当实际调用image代理的show()方法时，程序才会真正创建被代理对象。
        image.show();
    }
}

public interface Dog
{
    // info()方法声明
    void info();
    // run()方法声明
    void run();
}

public class GunDog implements Dog
{
    // info方法实现，仅仅打印一个字符串
    public void info()
    {
        System.out.println("我是一只猎狗");
    }
    // run方法实现，仅仅打印一个字符串
    public void run()
    {
        System.out.println("我奔跑迅速");
    }
}

public class TxUtil
{
    // 第一个拦截器方法:模拟事务开始
    public void beginTx()
    {
        System.out.println("=====模拟开始事务=====");
    }
    // 第二个拦截器方法:模拟事务结束
    public void endTx()
    {
        System.out.println("=====模拟结束事务=====");
    }
}

import java.lang.reflect.*;

public class MyInvokationHandler implements InvocationHandler
{
    // 需要被代理的对象
    private Object target;
    public void setTarget(Object target)
    {
        this.target = target;
    }
    // 执行动态代理对象的所有方法时，都会被替换成执行如下的invoke方法
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Exception
    {
        TxUtil tx = new TxUtil();
        // 执行TxUtil对象中的beginTx()。
        tx.beginTx();
        // 以target作为主调来执行method方法
        Object result = method.invoke(target, args);
        // 执行TxUtil对象中的endTx()。
        tx.endTx();
        return result;
    }
}

import java.lang.reflect.*;

public class MyProxyFactory
{
    // 为指定target生成动态代理对象
    public static Object getProxy(Object target) throws Exception
    {
        // 创建一个MyInvokationHandler对象
        MyInvokationHandler handler = new MyInvokationHandler();
        // 为MyInvokationHandler设置target对象
        handler.setTarget(target);
        // 创建、并返回一个动态代理
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), handler);
    }
}

public class Test
{
    public static void main(String[] args) throws Exception
    {
        // 创建一个原始的GunDog对象，作为target
        Dog target = new GunDog();
        // 以指定的target来创建动态代理
        Dog dog = (Dog) MyProxyFactory.getProxy(target);
        // 调用代理对象的info()和run()方法
        dog.info();
        dog.run();
    }
}

=====模拟开始事务=====
我是一只猎狗
=====模拟结束事务=====
=====模拟开始事务=====
我奔跑迅速
=====模拟结束事务=====

public interface OutputFactory
{
    // 仅定义一个方法用于返回输出设备。
    Output getOutput();
}

public class PrinterFactory implements OutputFactory
{
    public Output getOutput()
    {
        // 该工厂只负责产生Printer对象
        return new Printer();
    }
}

public class BetterPrinterFactory implements OutputFactory
{
    public Output getOutput()
    {
        // 该工厂只负责产生BetterPrinter对象
        return new BetterPrinter();
    }
}

public class Computer
{
    private Output out;

    public Computer(Output out)
    {
        this.out = out;
    }
    // 定义一个模拟获取字符串输入的方法
    public void keyIn(String msg)
    {
        out.getData(msg);
    }
    // 定义一个模拟打印的方法
    public void print()
    {
        out.out();
    }
    public static void main(String[] args)
    {
        // 使用PrinterFactory子类来创建OutputFactory
        OutputFactory of = new BetterPrinterFactory();
        // 将Output对象传入，创建Computer对象
        Computer c = new Computer(of.getOutput());
        c.keyIn("轻量级Java EE企业应用实战");
        c.keyIn("疯狂Java讲义");
        c.print();
    }
}

public class OutputFactoryFactory
{
    // 仅定义一个方法用于返回输出设备。
    public static OutputFactory getOutputFactory(String type)
    {
        if (type.equalsIgnoreCase("better"))
        {
            return new BetterPrinterFactory();
        } else
        {
            return new PrinterFactory();
        }
    }
}

public class Computer
{
    ...
    public static void main(String[] args)
    {
        // 使用OutputFactoryFactory工厂类创建OutputFactory
        OutputFactory of = OutputFactoryFactory.getOutputFactory("better");
        // 调用OuputFactory的方法获取Output对象，
        // 并将Output对象传入，创建Computer对象
        Computer c = new Computer(of.getOutput());
        c.keyIn("轻量级Java EE企业应用实战");
        c.keyIn("疯狂Java讲义");
        c.print();
    }
}

public class Singleton
{
    // 3.使用一个类变量缓存曾经创建的实例
    private static Singleton instance;
    // 1.将构造器使用private修饰，隐藏该构造器
    private Singleton()
    {
    }
    // 2.提供一个静态方法，用于返回Singleton实例
    // 该方法可以加入自定义的控制，保证只产生一个Singleton对象
    public static Singleton getInstance()
    {
        // 如果instance为null，表明还不曾创建Singleton对象
        // 如果instance不为null，则表明已经创建了Singleton对象，将不会执行该方法
        if (instance == null)
        {
            // 创建一个Singleton对象，并将其缓存起来
            instance = new Singleton();
        }
        return instance;
    }
}

public class SingletonTest
{
    public static void main(String[] args)
    {
        // 创建Singleton对象不能通过构造器，只能通过getInstance方法
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        // 将输出true
        System.out.println(s1 == s2);
    }
}