package com.zss.rbacproject.config;

import org.springframework.context.annotation.Bean;
import org.springframework.web.servlet.LocaleResolver;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Locale;

public class MyLocalResolver implements LocaleResolver {
    //放到bean里面
    @Bean
    public LocaleResolver localeResolver(){
        return new MyLocalResolver();
    }

    @Override
    public Locale resolveLocale(HttpServletRequest request) {
        //获取语言参数请求
        String language=request.getParameter("language");
        //获得默认的编码
        Locale locale=Locale.getDefault();
        //如果携带了国际化参数
        if (language!=null||language!=""){
            String []split=language.split("_");
            //新建立国家地区
            locale=new Locale(split[0],split[1]);

        }
        return locale;
    }

    @Override
    public void setLocale(HttpServletRequest request, HttpServletResponse response, Locale locale) {

    }
}

@Controller
@RequestMapping("/test")
public class RequestMappingController {
	//此时请求映射所映射的请求的请求路径为：/test/testRequestMapping
    @RequestMapping("/testRequestMapping")
    public String testRequestMapping(){
        return "success";
    }
}

@RequestMapping( value = {"/","/hi"})

method = RequestMethod.GET

@RequestMapping("/target")
public String toTarget(){
    return "target";
}

@RequestMapping(value = "/target",
        method = RequestMethod.POST,
        params = {"username","password!=123456"}
)
public String toTarget(){
    return "target";
}

@RequestMapping(value = "/target",
        method = RequestMethod.POST,
        params = {"username","password!=123456"},
        headers = {"Host=localhost:8080"}
)

//接受test/（参数）的地址
    @RequestMapping("/test/{id}")
    //将id标记为Integer id的对应信息
    public String test(@PathVariable("id")Integer id){
        System.out.println(id);
        return "target";
    }

@RequestMapping("/test")
public String test(@RequestBody String body){
    System.out.println(body);
    return "target";
}

@RequestMapping("/test")
public void test(HttpServletResponse httpServletResponse) throws IOException {
    httpServletResponse.getWriter().print("你好");
}

@RequestMapping("/test")
@ResponseBody
public String test()  {
    //加上注解之后，返回的东西不再是页面，而是响应体
    return "hi";
}

@RequestMapping("/test")
@ResponseBody
public User test()  {
    return new User("zss","2001","男",20,"200@qq.com");
}

@RequestMapping("/test")
public String test(RequestEntity<String> entity){
    System.out.println(entity);
    System.out.println(entity.getBody());
    //除此之外还有很多方法
    return "target";
}

@RequestMapping("/test")
@ResponseBody
public String test(String username,String password)  {
    System.out.println(username+password);
    return username;
}

@RequestMapping("/testDown")
public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws IOException {
    //获取ServletContext对象
    ServletContext servletContext = session.getServletContext();
    //获取服务器中文件的真实路径
    String realPath = servletContext.getRealPath("/static/img/夜空.png");
    //创建输入流
    InputStream is = new FileInputStream(realPath);

    //创建字节数组，is.available()表示创建的字节流的大小
    byte[] bytes = new byte[is.available()];
    //将流读到字节数组中
    is.read(bytes);
    //创建HttpHeaders对象设置响应头信息
    MultiValueMap<String, String> headers = new HttpHeaders();
    //设置要下载方式以及下载文件的名字
    headers.add("Content-Disposition", "attachment;filename=天空.png");
    //设置响应状态码
    HttpStatus statusCode = HttpStatus.OK;
    //创建ResponseEntity对象，传入数组，响应头，与状态描述
    ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, statusCode);
    //关闭输入流
    is.close();
    return responseEntity;
}

@RequestMapping("/textup")
public String textUp(MultipartFile photo, HttpSession session) throws IOException {
    String fileName=photo.getOriginalFilename();
    //获得服务器的路径
    ServletContext servletContext=session.getServletContext();
    String path=servletContext.getRealPath("/static/img");
    //设置上传路径
    //首先判断路劲存在与否
    File file=new File(path);
    if(!file.exists()){
        file.mkdir();
    }
    /*File.separator表示分隔符*/
    String finalPath=path+File.separator+fileName;
    photo.transferTo(new File(finalPath));
    return "target";
}

//获得文件后缀,包括点
String suffixName=fileName.substring(fileName.lastIndexOf("."));
String uuid= UUID.randomUUID().toString();
fileName=uuid+suffixName;

public class AddServlet extends HttpServlet {
    @Override
    public void doPost(HttpServletRequest req, HttpServletResponse resp) throws  IOException {
        //注意要设置编码格式，非常重要，post方式要进行设置
        req.setCharacterEncoding("UTF-8");
        String fName=req.getParameter("fName");
        int price=Integer.parseInt(req.getParameter("price"));
        int fCount=Integer.parseInt(req.getParameter("fCount"));
        String remark=req.getParameter("remark");
        Integer fid=Integer.parseInt(req.getParameter("fid"));


        FruitDAOImpl fruitDAO=new FruitDAOImpl();
        try {
            fruitDAO.addFruit(new Fruit(fName,price,fCount,remark,fid));
        } catch (SQLException | ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

public interface testService {
    public void doService();
}

public class testServiceImpl  implements testService {
    @Override
    public void doService() {
        System.out.println("执行了service方法");
    }
}

public static void main(String[] args) {
    //这里使用了正转的方法，创建类交给我们来进行
    testService test=new testServiceImpl();
    test.doService();
}

public static void main(String[] args) {
    //使用spring容器创建对象
    //指定spring配置文件名称
    String config="beans.xml";
    //创建spring容器的对象，applicationcontext---代表spring容器
    //ClassPathXmlApplicationContext表示从类路径中加载文件
    ApplicationContext  applicationContext=new ClassPathXmlApplicationContext(config);
    //从容器中根据id获得类的真实类型
    testService test=(testService) applicationContext.getBean("test");
    test.doService();
}

public testServiceImpl() {
    System.out.println("对象被创建了");
}

//获取容器中定义对象的数量
int nums=applicationContext.getBeanDefinitionCount();
System.out.println(nums);
//获取容器中每一个定义对象的名称
String []names=applicationContext.getBeanDefinitionNames();
for (String name:names){
    System.out.println(name);
}

package com.zss.pojo;

/**
 * @author zss
 */
public class Student {
    String name;
    Integer age;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

public static void main(String[] args) {
    String config="applicationContext.xml";
    ApplicationContext  applicationContext=new ClassPathXmlApplicationContext(config);
    Student student= (Student) applicationContext.getBean("myStudent");
    System.out.println(student);
}

public class AppTest 
{
    @Test
    public void test01() {
        String config = "applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(config);
        Student student = (Student) applicationContext.getBean("myStudent");
        System.out.println(student);
    }
    
}

package com.zss.pojo;

public class School {
    String name;
    String address;

    public void setName(String name) {
        this.name = name;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

public Student(String name, Integer age, School school) {
    this.name = name;
    this.age = age;
    this.school = school;
}

@Around("你要增加的事务功能的业务方法名称")
Object myAround(){
     开启事务，spring给你开启
  try{
     buy(1001,10);
	  spring的事务管理器.commit();
  }catch(Exception e){
       spring的事务管理器.rollback();
  }
 
}

//指定的方法必须在事务内执行，若当前存在事务，就加入到当前事务中，若当前没有事务，则创建一个新的事务，是spring默认的事务传播行为，比如方法1调用方法2，而方法1本身已经声明事务，而方法2被 PROPAGATION_REQUIRED修饰，那么方法2与方法1同属于一个事务，如果方法1不是事务，那么方法2会自动创建一个事务
PROPAGATION_REQUIRED
          //有事务的时候，新建事务，将原来的挂起，没有事务，也创建事务
PROPAGATION_REQUIRES_NEW 
  //如果方法被设置成PROPAGATION_SUPPORTS，那么该方法拥有事务也可以，不拥有事务也可以执行，查询操作有无事务皆可
PROPAGATION_SUPPORTS
//几乎不会使用
PROPAGATION_MANDATORY
PROPAGATION_NESTED
PROPAGATION_NEVER
PROPAGATION_NOT_SUPPORTED

public class BuyServiceImpl implements BuyService {
    GoodsDAO goodsDAO;
    SaleDAO saleDAO;
    @Override
    public void buyGood() {
        //我首先购买了一部手机所以要获得手机这个对象
        Goods goods=goodsDAO.getGood("手机");
        //sale中加入这个
        saleDAO.addSale(goods);
        //减少数量
        goodsDAO.reduceGoodNum(goods);
    }

    public void setGoodsDAO(GoodsDAO goodsDAO) {
        this.goodsDAO = goodsDAO;
    }

    public void setSaleDAO(SaleDAO saleDAO) {
        this.saleDAO = saleDAO;
    }
}

@Transactional(propagation = Propagation.REQUIRED,
    isolation = Isolation.DEFAULT,readOnly = false,rollbackFor = {

    ArithmeticException.class})
//其实上面的赋值大都是默认的，而且默认运行异常就会回滚事务，所以只要使用@Transactional也可以，但是此注解只会对public起作用
    public void buyGood() {
        //我首先购买了一部手机所以要获得手机这个对象
        Goods goods=goodsDAO.getGood("手机");
        saleDAO.addSale(goods);
        System.out.println(10/0);
        goodsDAO.reduceGoodNum(goods);
    }

    public void setGoodsDAO(GoodsDAO goodsDAO) {
        this.goodsDAO = goodsDAO;
    }

    public void setSaleDAO(SaleDAO saleDAO) {
        this.saleDAO = saleDAO;
    }
}

package com.zss.pojo;

/**
 * @author zss
 */
public class Student {
    private Integer id;
    private String name;
    private String email;
    private Integer age;

    public Student() {
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }

    public Integer getAge() {
        return age;
    }

    public Student(Integer id, String name, String email, Integer age) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                ", age=" + age +
                '}';
    }
}

public interface StudentService {
    List<Student> getStudents();

    int insertStudent();
}

public class StudentServiceImpl implements StudentService {

    private StudentDAO studentDAO;

    /**使用set注入进行赋值*/
    public void setStudentDAO(StudentDAO studentDAO) {
        this.studentDAO = studentDAO;
    }

    @Override
    public List<Student> getStudents() {
        return studentDAO.getStudentList();
    }

    @Override
    public int insertStudent() {
       return studentDAO.insertStudent();
    }
}

<!--声明数据源对象，使用阿里巴巴的druid连接池-->
<bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
      init-method="init" destroy-method="close">
    <!--使用set注入提供配置信息，如果在properties文件中进行看配置，则需要使用${属性名称的方式}，十jdbc了解到他的位置
<context:property-placeholder location="jdbc.properties"/>
-->
    <property name="url" value="jdbc:mysql://localhost:3306/school"/>
    <property name="username" value="root"/>
    <property name="password" value="200101"/>
</bean>

public class AppTest 
{
    @Test
    public void test01(){
        String config="applicationContext.xml";
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext(config);
        String[] names=applicationContext.getBeanDefinitionNames();
        for (String name:names){
            System.out.println(name);
            System.out.println(applicationContext.getBean(name));
        }
    }
}

//这些方法的提交是自动提交的
@Test
public void test02(){
    String config="applicationContext.xml";
    ApplicationContext applicationContext=new ClassPathXmlApplicationContext(config);
    List<Student> list=new ArrayList<>();
    StudentService studentService=(StudentService) applicationContext.getBean("studentService");
    list=studentService.getStudents();
    for (Student student:list){
        System.out.println(student);
    }
}

package com.zss.pojo;

import org.springframework.stereotype.Component;

/**
 * @author zss
 */
//我们也可以不指定对象名称，spring默认指定对象名称，第一个字母小写

@Component(value = "myStudent")
public class Student {
    String name;
    Integer age;
    School school;

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setSchool(School school) {
        this.school = school;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }
}

@Test
public void test01() {
    String config = "applicationContext.xml";
    //通过无参构造方法进行设置
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext(config);
    Student student = (Student) applicationContext.getBean("myStudent");
    System.out.println(student);
}

@Value("张三")
String name;
@Value("15")
Integer age;

package com.zss.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component("myschool")
public class School {
    @Value("北京大学")
    String name;
    @Value("北京")
    String address;

    public void setName(String name) {
        this.name = name;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

@Value("张三")
String name;
@Value("15")
Integer age;
@Autowired
School school;

@Autowired
        @Qualifier("myschool")
School school;

@Resource
School school;

@Resource(name = "myschool")
School school;

@Aspect
public class MyIncation  {
    //在目标方法之前进行执行,value表示切入点位置,在saygood（方法前面执行），如果拥有参数的话，需要在参数的位置使用Interger，String等等类型，不需要参数名称
    @Before(value = "execution( void com.zss.service.impl.TestServiceImpl.*(..))")
    public void myBefore(){
        System.out.println("我是前置方法");
    }
}

//res是目标方法的返回值，可以根据返回值做切面的处理,如果没有返回值则为空，Object res相当于首先执行了sayhi等方法，之后拿到返回值进行后续处理
@AfterReturning(value = "execution( void com.zss.service.impl.TestServiceImpl.*(..))",returning = "res")
public void myAfter(Object res){
    System.out.println("我是后置方法");

    if (res==null){
        System.out.println("返回值为空");
    }
}

/*可以在方法执行前，执行后都能增强功能，可以控制目标方法是否被执行，修改原来目标方法的执行结果，影响最后的调用
* ProceedingJoinPoint相当于jdk动态代理的method，执行目标方法，获得返回值*/
@Around(value = "execution( * com.zss.service.impl.TestServiceImpl.*(..))")
public Object myAround(ProceedingJoinPoint point) throws Throwable {
    //实现环绕通知
    Object result;
    System.out.println("环绕通知前");
    //目标方法调用
    result=point.proceed();
    System.out.println("提交事务");

    return result;
}

JoinPoint表示切入点

//我们可以对这个进行判断，再去决定是否调用原方法
if (point==null){
//目标方法调用
result=point.proceed();}

@AfterThrowing(value = "execution( * com.zss.service.impl.TestServiceImpl.*(..))",throwing = "ex")
public void myThrowing(Exception ex){
    System.out.println("发生了异常，发送短信");
}

public class AppTest 
{
    @Test
    public void test01() {
        String config="applicationContext.xml";
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext(config);
        //从容器中获取目标对象
        TestService proxy=(TestService) applicationContext.getBean("testService");
        System.out.println(proxy.getClass().getName());
        //通过代理的对象执行方法，实现目标方法执行时，增强功能
        proxy.sayGood();
    }
}