java_study

---

typora-root-url: src

java——study（mspaint）

一. 多线程详解（java.thread）

重点：线程的实现和线程的同步

1. 线程简介

多任务，多线程

• 普通方法调用和多线程

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tk7KsmrA-1666515575309)(F:\study\javaStudy\study\src\1.png)]

• 在操作系统中运行的程序就是进程，比如你的qq，播放器……

Process与Thread

• 程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
• 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。
• 通常在一个进程中可以包含若干个 线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。
  • 注意：很多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，多有就有同时执行的错局。

• main（）称之为主线程，为系统的入口，用于执行整个程序；

2. 线程创建

(1) 继承Thread类

• 自定义线程类继承 Thread类

• 重写 run（） 方法，编写线程执行体

• 创建线程对象，调用 start（） 方法启动线程

  • public class TestThread extends Thread{
        @Override
        public void run() {
    //        run() 方法线程体
            for (int i = 0; i < 20; i++) {
                System.out.println("我在看代码");
            }
        }
    
        public static void main(String[] args) {
            //main线程,主线程
            // 创建一个线程对象
            TestThread testThread = new TestThread();
            // 调用start()方法开启线程
            testThread.start();
            for (int i = 0; i < 20; i++) {
                System.out.println("我在学多线程"+i);
            }
        }
    
    }
    
    

• 总结：注意，线程开启不一定立即执行，由cpu调度执行

多线程同步下载图片

• 新建package为lib，放入commons-io包，右键add as libarily

• import org.apache.commons.io.FileUtils;
  
  import java.io.File;
  import java.io.IOException;
  import java.net.URL;
  
  public class TestThread2 extends Thread{
      //练习thread,实现多线程同步下载图片
      private String url;//网络图片地址
      private String name;//保存的文件名
      public TestThread2(String url,String name){
          this.url = url;
          this.name = name;
      }
      //下载图片线程的执行体
      @Override
      public void run() {
          WebDownload webDownload = new WebDownload();
          webDownload.download(url,name);
          System.out.println("下载了文件名："+ name);
      }
  
      public static void main(String[] args) {
          TestThread2 t1 = new TestThread2("https://pic.cnblogs.com/face/1418974/20181015113902.png","1.jpg");
          TestThread2 t2 = new TestThread2("https://pic.cnblogs.com/face/1418974/20181015113902.png","2.jpg");
          TestThread2 t3 = new TestThread2("https://pic.cnblogs.com/face/1418974/20181015113902.png","3.jpg");
  
          t1.start();
          t2.start();
          t3.start();
      }
  }
  
  //下载器
  class WebDownload{
      //下载方法
      public void download(String url,String name){
          try {
              FileUtils.copyURLToFile(new URL(url),new File(name));
          } catch (IOException e) {
              e.printStackTrace();
              System.out.println("IO异常，download方法出现问题");
          }
      }
  }
  
  
  

(2) 实现Runnable接口

• 定义MyRunnable 类实现 Runnable 接口

• **实现run（）**方法，编写线程执行体

• 创建线程对象，调用 **start（）**方法启动线程

• public class TestThread3 implements  Runnable{
      //创建线程方式2：实现Runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
  
      @Override
      public void run() {
          // run 方法线程体
          for (int i = 0; i < 200; i++) {
              System.out.println("我在看代码-----");
          }
      }
  
      public static void main(String[] args) {
          // 创建runnable接口的实现类对象
          TestThread3 testThread3 = new TestThread3();
          //创建线程对象，通过线程对象来开启我们的线程，代理
  //        Thread thread = new Thread(testThread3);
  //        thread.start();
          new Thread(testThread3).start();
          for (int i = 0; i < 1000; i++) {
              System.out.println("我在学习多线程---"+i);
          }
      }
  }
  
  
  

• 实现图片的多线程下载

• import org.apache.commons.io.FileUtils;
  
  import java.io.File;
  import java.io.IOException;
  import java.net.URL;
  
  public class TestThread2 extends Thread{
      //练习thread,实现多线程同步下载图片
      private String url;//网络图片地址
      private String name;//保存的文件名
      public TestThread2(String url,String name){
          this.url = url;
          this.name = name;
      }
      //下载图片线程的执行体
      @Override
      public void run() {
          WebDownload webDownload = new WebDownload();
          webDownload.download(url,name);
          System.out.println("下载了文件名："+ name);
      }
  
      public static void main(String[] args) {
          TestThread2 t1 = new TestThread2("https://pic.cnblogs.com/face/1418974/20181015113902.png","1.jpg");
          TestThread2 t2 = new TestThread2("https://pic.cnblogs.com/face/1418974/20181015113902.png","2.jpg");
          TestThread2 t3 = new TestThread2("https://pic.cnblogs.com/face/1418974/20181015113902.png","3.jpg");
  
          new Thread(t1).start();
          new Thread(t2).start();
          new Thread(t3).start();
      }
  }
  
  //下载器
  class WebDownload{
      //下载方法
      public void download(String url,String name){
          try {
              FileUtils.copyURLToFile(new URL(url),new File(name));
          } catch (IOException e) {
              e.printStackTrace();
              System.out.println("IO异常，download方法出现问题");
          }
      }
  }
  
  
  

• 小结

  • 继承Thread类
    • 子类继承Thread类具备多线程能力
    • 启动线程：子类对象.start();
    • 不建议使用：避免oop单继承局限性
  • 实现Runnable接口
    • 实现接口Runnable具有多线程能力
    • 启动线程：传入目标对象+Thread对象.start()
    • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多线程使用
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F6hpNyE7-1666515575309)(F:\study\javaStudy\study\src\2.png)]

初始并发问题

• // 发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
  public class TestThread4 implements Runnable {
      //多个线程同时操作同一个对象
      //买火车票的例子
  
      //票数
      private int ticketNums = 10;
  
      @Override
      public void run() {
          while (true){
              if(ticketNums<=0){
                  break;
              }
  //            模拟延时
              try {
                  Thread.sleep(200);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              System.out.println(Thread.currentThread().getName()+"--->拿到了第" + ticketNums-- + "票");
          }
      }
  
      public static void main(String[] args) {
          TestThread4 ticket = new TestThread4();
  
          new Thread(ticket,"小名").start();
          new Thread(ticket,"张三").start();
          new Thread(ticket,"李四").start();
      }
  }
  
  

龟兔赛跑 —— Race

1. 首先来个赛道距离，然后要离终点越来越近
2. 判断比赛是否结束
3. 打印出胜利者
4. 龟兔赛跑开始
5. 故事中是乌龟赢的，兔子需要睡觉，所以我们来模拟兔子睡觉
6. 终于乌龟赢得了比赛

• public class Race implements Runnable{
      //模拟龟兔赛跑
  
      // 胜利者
      private  static  String winner;
      @Override
      public void run() {
          for (int i = 0; i <= 100; i++) {
              //模拟兔子睡觉
              if(Thread.currentThread().getName().equals("兔子") && i%10 == 0){
                  try {
                      Thread.sleep(10);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
              //判断比赛是否结束
              boolean flag = gameOver(i);
              if(flag){
                  break;
              }
              System.out.println(Thread.currentThread().getName()+"跑了" + i + "步");
          }
      }
  
      //普安段是否完成比赛
      private  boolean gameOver (int steps) {
          if( winner != null){
              return true;
          }{
              if(steps >= 100){
                  winner = Thread.currentThread().getName();
                  System.out.println("winner is" + winner);
                  return true;
              }
          }
          return false;
      }
  
      public static void main(String[] args) {
          Race race = new Race();
          new Thread(race,"兔子").start();
          new Thread(race,"乌龟").start();
      }
  }
  
  

(3) 实现Calloable接口（了解即可）

1. 实现Callable接口，需要返回值类型
2. 重写call方法，需要抛出异常
3. 创建目标对象
4. 创建执行服务：ExecutorService ser = Executors.newFixedThreadPllo(1);
5. 提交执行：Future result1 = ser.submit(t1);
6. 获取结果：boolea r1 = result1.get()
7. 关闭服务：ser.shutdownNow();

• 多线程下载图片

• package demo;
  
  import com.sun.org.apache.xpath.internal.operations.Bool;
  import org.apache.commons.io.FileUtils;
  
  import java.io.File;
  import java.io.IOException;
  import java.net.URL;
  import java.util.concurrent.*;
  
  public class TestCallable implements Callable<Boolean> {
      private String url;//网络图片地址
      private String name;//保存的文件名
      public TestCallable(String url,String name){
          this.url = url;
          this.name = name;
      }
      //下载图片线程的执行体
      @Override
      public Boolean call() {
          WebDownload webDownload = new WebDownload();
          webDownload.download(url,name);
          System.out.println("下载了文件名："+ name);
          return true;
      }
  
      public static void main(String[] args) throws ExecutionException, InterruptedException {
          TestCallable t1 = new TestCallable("https://pic.cnblogs.com/face/1418974/20181015113902.png","1.jpg");
          TestCallable t2 = new TestCallable("https://pic.cnblogs.com/face/1418974/20181015113902.png","2.jpg");
          TestCallable t3 = new TestCallable("https://pic.cnblogs.com/face/1418974/20181015113902.png","3.jpg");
  //        1. 创建执行服务：
          ExecutorService ser = Executors.newFixedThreadPool(3);
  //        2. 提交执行：
          Future<Boolean> r1 = ser.submit(t1);
          Future<Boolean> r2 = ser.submit(t2);
          Future<Boolean> r3 = ser.submit(t3);
  //        3. 获取结果：
          boolean rs1 = r1.get();
          boolean rs2 = r2.get();
          boolean rs3 = r3.get();
          System.out.println(rs1);
          System.out.println(rs2);
          System.out.println(rs3);
  //        4. 关闭服务：
          ser.shutdownNow();
      }
  }
  
  //下载器
  class WebDownload{
      //下载方法
      public void download(String url,String name){
          try {
              FileUtils.copyURLToFile(new URL(url),new File(name));
          } catch (IOException e) {
              e.printStackTrace();
              System.out.println("IO异常，download方法出现问题");
          }
      }
  }
  

静态代理

• 总结：

  • 真实对象和代理对象都要实现同一个接口
  • 代理对象要代理真实对象
  • 好处
    • 代理对象可以做很多真实对象做不了的事情
    • 真实对象专注做自己的事情

• public class StaticProxy {
      public static void main(String[] args) {
          new Thread( ()-> System.out.println("我爱你")).start();
          You you = new You();
  
          WeddingCompay weddingCompay = new WeddingCompay(you);
          weddingCompay.HappyMarry();
      }
  }
  
  interface Marry{
      void HappyMarry();
  }
  
  //真实角色，你去结婚
  class You implements Marry{
      @Override
      public void HappyMarry() {// alt+inst  这就是真实对象
          System.out.println("要结婚了");
      }
  }
  
  //代理角色，帮助你结婚
  class WeddingCompay implements Marry{
  //    代理谁 ----》 真实目标角色
      private Marry target;
  
      public WeddingCompay(Marry target) {
          this.target = target;
      }
  
      @Override
      public void HappyMarry() {
          before();
          this.target.HappyMarry();
          after();
      }
  
      private void before() {//alt+ent
          System.out.println("结婚之前，布置现场");
      }
      private void after() {
          System.out.println("结婚之后，收尾款");
      }
  
  }
  

Lamda表达式

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-opsEVODF-1666515575310)(F:\study\javaStudy\study\src\3.png)]

• 理解Functional Interface（函数式接口）是学习java8 Lambda表达式的关键所在。

• 函数式接口的定义：

  • 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。

  • public interface Runnable{
        public abstract void run();
    }
    

  • 对于函数式接口， 我们可以通过lambda表达式来创建该接口的对象。

案例1

• package lambda;
  /*
  推导Lambda表达式
   */
  public class TestLambda {
  
      public static void main(String[] args) {
          ILike like = new Like();
          like.lambda();
      }
  }
  
  
  // 1，定义一个函数式接口
  interface ILike{
      void lambda();
  }
  
  //2. 实现类
  class Like implements ILike{
      @Override
      public void lambda() {
          System.out.println(" i like lambda");
      }
  }
  

优化

• package lambda;
  /*
  推导Lambda表达式
   */
  public class TestLambda {
      //3. 静态内部类
      static class Like2 implements ILike{
          @Override
          public void lambda() {
              System.out.println("i like lambda2");
          }
      }
      public static void main(String[] args) {
          ILike like = new Like();
          like.lambda();
          like = new Like2();
          like.lambda();
  
          // 4.局部内部类
          class Like3 implements ILike{
              @Override
              public void lambda() {
                  System.out.println("i like lambda3");
              }
          }
          like = new Like3();
          like.lambda();
  
          //5. 匿名内部类，没有类的名称，必须借助接口或者父类
          like = new ILike() {
              @Override
              public void lambda() {
                  System.out.println("i like lambda4");
              }
          };
          like.lambda();
  
          // 6. 用lamdba简化
          like = ()-> {
              System.out.println("i like lambda5");
          };
          like.lambda();
      }
  }
  
  
  // 1，定义一个函数式接口
  interface ILike{
      void lambda();
  }
  
  //2. 实现类
  class Like implements ILike{
      @Override
      public void lambda() {
          System.out.println(" i like lambda");
      }
  }
  

案例2

• package lambda;
  
  public class TestLamdba2 {
      public static void main(String[] args) {
  
          ILove love = (int a)-> {
              System.out.println("i love you" + a);
          };
          love.love(2);
      }
  }
  
  interface ILove{
      void love(int a);
  }
  
  
  

• 总结

  • lambda表达式只能有一行代码的情况下才能简化为一行，如果有多行，那么就用代码 块包裹
  • 前提是接口为函数式接口
  • 多个参数也可以去掉参数类型，要去掉就都去掉，必须加括号

简化

• package lambda;
  
  public class TestLamdba2 {
      public static void main(String[] args) {
          ILove love = null;
  //        1. lambda表示简化
         // ILove love = (int a)-> {
          //    System.out.println("i love you" + a);
         // };
  //        简化1. 参数类型
          love = (a)->{
              System.out.println("i love you" + a);
          };
  
  //        简化2。简化括号
          love = a->{
              System.out.println("i love you" + a);
          };
  //        简化3. 去掉花括号
          love = a->  System.out.println("i love you" + a);
  //        总结：
  //            lambda表达式只能有一行代码的情况下才能简化为一行，如果有多行，那么就用代码 块包裹
  //             前提是接口为函数式接口
  //        多个参数也可以去掉参数类型，要去掉就都去掉，必须加括号
          love.love(521);
      }
  }
  
  interface ILove{
      void love(int a);
  }
  
  
  

3. 线程状态

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XVd1ZwCy-1666515575310)(F:\study\javaStudy\study\src\4.png)]

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lAS89Zj6-1666515575311)(F:\study\javaStudy\study\src\5.png)]

• 线程方法

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7jSbplLi-1666515575311)(F:\study\javaStudy\study\src\6.png)]

(1)停止线程

• 不推荐使用JDK提供的 stop()、destory()方法。【已废弃】

• 推荐线程自己停止下来

• 建议使用一个标志位进行终止变量当flag=false，则终止线程运行。

• package state;
  
  //测试stop
  //1. 建议 线程正常停止 ---> 利用次数，不建议死循环。
  //2. 建议使用标志位 ---》  设置一个标志位
  //3. 不要使用stop或者destory等过时或者JDK不建议使用的方法
  public class TestStop implements Runnable{
  //    1. 设置一个标识位
      private boolean flag = true;
      @Override
      public void run() {
          int i = 0;
          while (flag){
              System.out.println("run……Thread" + i++);
          }
      }
  // 2.设置一个公开的方法停止线程，转化标志位
      public  void stop() {
          this.flag = false;
      }
      public static void main(String[] args) {
          TestStop testStop = new TestStop();
  
          new Thread(testStop).start();
          for (int i = 0; i < 1000; i++) {
              System.out.println("main" + i);
              if(i==900){
  //              调用stop方法切换标志位，让线程停止
                  testStop.stop();
                  System.out.println("线程该停止了");
              }
          }
      }
  }
  
  

(2)线程休眠

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eFBZJu4z-1666515575311)(F:\study\javaStudy\study\src\7.png)]

案例1

• package state;
  
  //模拟网络延时：放大问题的发生性
  public class TestSleep implements Runnable {
      //多个线程同时操作同一个对象
      //买火车票的例子
  
      //票数
      private int ticketNums = 10;
  
      @Override
      public void run() {
          while (true){
              if(ticketNums<=0){
                  break;
              }
  //            模拟延时
              try {
                  Thread.sleep(200);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              System.out.println(Thread.currentThread().getName()+"--->拿到了第" + ticketNums-- + "票");
          }
      }
  
      public static void main(String[] args) {
          TestSleep ticket = new TestSleep();
  
          new Thread(ticket,"小名").start();
          new Thread(ticket,"张三").start();
          new Thread(ticket,"李四").start();
      }
  }
  

案例2

• package state;
  
  
  import java.text.SimpleDateFormat;
  import java.util.Date;
  
  //模拟倒计时
  public class TestSleep2 {
      public static void main(String[] args) {
  //        try {
  //            tenDown();
  //        } catch (InterruptedException e) {
  //            e.printStackTrace();
  //        }
  //        打印当前时间
          Date startTime = new Date(System.currentTimeMillis());//获取系统当前时间
  
          try {
              Thread.sleep(1000);
              System.out.println(new SimpleDateFormat("HH:MM:SS").format(startTime));
              startTime = new Date(System.currentTimeMillis());//更新当前时间
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
  //    模拟倒计时
      public static void tenDown() throws InterruptedException {
          int num = 10;
          while (true){
              Thread.sleep(1000);
              System.out.println(num--);
              if(num<=0){
                  break;
              }
          }
      }
  }
  
  

(3)线程礼让

• 礼让线程，让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 让CPU重新调度，礼让不一定成功！看CPU心情；

案例

• package state;
  
  public class TestYield {
      public static void main(String[] args) {
          MyYielf myYielf = new MyYielf();
          new Thread(myYielf,"a").start();
          new Thread(myYielf,"b").start();
      }
  }
  
  class MyYielf implements  Runnable{
      @Override
      public void run() {
          System.out.println(Thread.currentThread().getName()+"线程开始执行");
          Thread.yield();//礼让
          System.out.println(Thread.currentThread().getName()+"线程停止执行");
      }
  }
  

(4)Join

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6A3pcy9r-1666515575312)(F:\study\javaStudy\study\src\8.png)]

案例

• package state;
  
  //测试join方法,想象为插队
  public class TestJoin implements Runnable{
      @Override
      public void run() {
          for (int i = 0; i < 1000; i++) {
              System.out.println("线程Vip来了" + i);
          }
      }
  
      public static void main(String[] args) throws InterruptedException {
          TestJoin testJoin = new TestJoin();
          Thread thread = new Thread(testJoin);
          thread.start();
          
  //        主线程
          for (int i = 0; i < 500; i++) {
              if(i==200){
                  thread.join();//插队
              }
              System.out.println("main" + i);
          }
      }
  }
  
  

(5)线程状态观测

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9MWh8qQ2-1666515575312)(F:\study\javaStudy\study\src\9.png)]

案例

• package state;
  
  public class TestState {
      public static void main(String[] args) throws InterruptedException {
          Thread thread = new Thread( ()-> {
              for (int i = 0; i < 5; i++) {
                  try {
                      Thread.sleep(1000);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
              System.out.println("");
          });
  
  //        观察状态
          Thread.State state = thread.getState();
          System.out.println(state);
           //观察启动 后
  
          thread.start();//启动
  
          state = thread.getState();
          System.out.println(state);
  
          while (state != Thread.State.TERMINATED){//只要线程不终止,就一直输出状态
              Thread.sleep(1000);
              state = thread.getState();//更新线程状态
              System.out.println(state);
          }
  //        thread.start(); 结束的进程是不能在 被启动的
      }
  }
  
  

(6)线程优先级

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lZtsaTHR-1666515575312)(F:\study\javaStudy\study\src\10.png)]
• 优先级低只是意味着获取调度的概率低。并不是优先级低就不会被调用了。着都是看cpu的调度 。

案例

• package state;
  
  //测试线程的优先级
  public class TestPriority {
      public static void main(String[] args) {
  //        主线程默认优先级
          System.out.println(Thread.currentThread().getName()+ "---->" + Thread.currentThread().getPriority());
          MyPriority myPriority = new MyPriority();
  
          Thread t1 = new Thread(myPriority);
          Thread t2 = new Thread(myPriority);
          Thread t3 = new Thread(myPriority);
          Thread t4 = new Thread(myPriority);
          Thread t5 = new Thread(myPriority);
          Thread t6 = new Thread(myPriority);
  
  //        先设置优先级,在启动
          t1.start();
  
          t2.setPriority(1);
          t2.start();
  
          t3.setPriority(4);
          t3.start();
  
          t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
          t4.start();
  
          t5.setPriority(8);
          t5.start();
  
          t6.setPriority(7);
          t6.start();
      }
  }
  
  class MyPriority implements Runnable{
      @Override
      public void run() {
          System.out.println(Thread.currentThread().getName()+ "---->" + Thread.currentThread().getPriority());
      }
  }
  

(7)守护（daemon）线程

• 线程分为 用户线程 和 守护线程
• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• 如：后台造作日志、监控内存、垃圾回收等待

案例

• package state;
  
  //测试守护线程
  //上帝守护你
  public class TestDaemon {
      public static void main(String[] args) {
          God god = new God();
          You you = new You();
  
          Thread thread = new Thread(god);
          thread.setDaemon(true);//默认是false表示是用户线程,正常的线程都是用户线程
  
          thread.start();//上帝守护线程启动
           new Thread(you).start();//你 用户线程启动
      }
  }
  
  
  //上帝
  class God implements  Runnable{
      @Override
      public void run() {
          while (true) {
              System.out.println("上帝保佑着你");
          }
      }
  }
  
  //你
  class You implements Runnable{
      @Override
      public void run() {
          for (int i = 0; i < 36500; i++) {
              System.out.println("你一生呢个都开心的活着");
          }
          System.out.println("=====goodbye!========");
      }
  }
  

4. 线程同步

• 多个线程操作同一个资源
• 并发: 同一个对象 被 多个线程 同时造作
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UbbKibZt-1666515575320)(F:\study\javaStudy\study\src\11.png)]

队列和锁

• 形成条件：队列+ 锁
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JQdDpjiJ-1666515575320)(F:\study\javaStudy\study\src\12.png)]

三大不安全案列

案例一（买票）

• package syn;
  
  
  //不安全的买票
  //线程不安全有负数
  public class UnsafeBuyTicket {
      public static void main(String[] args) {
          BuyTicket station = new BuyTicket();
          new Thread(station,"苦逼的我").start();
          new Thread(station,"牛逼的你们").start();
          new Thread(station,"可恶的黄牛党").start();
      }
  }
  
  
  class BuyTicket implements Runnable{
      //票
      private  int ticketNums = 10;
      boolean flag = true;//外部停止方式
      @Override
      public void run() {
          // 买票
          while (flag) {
              try {
                  buy();
              } catch (Exception e) {
                  throw new RuntimeException(e);
              }
          }
      }
  
      private  void buy() throws InterruptedException {
          //判断是否有票
          if(ticketNums <= 0){
              flag = false;
              return;
          }
          //模拟延时
          Thread.sleep(100);
          //买票
          System.out.println(Thread.currentThread().getName()+ "拿到" + ticketNums--);
      }
  }
  

• 不安全的买票

• 线程不安全有负数

案例二（取钱）

• package syn;
  
  //不安全的取钱
  //两个人去引号取钱，账户
  public class UnsafeBank {
      public static void main(String[] args) {
          //账户
          Account account = new Account(100,"结婚基金");
          Drawing you = new Drawing(account,50,"你");
          Drawing girFriend = new Drawing(account,100,"girFriend");
          you.start();
          girFriend.start();
  
      }
  }
  
  
  //账户
  class Account{
      int money;//余额
      String name;// 卡名
  
      public Account(int money, String name) {
          this.money = money;
          this.name = name;
      }
  }
  
  //银行：模拟取款
  class Drawing extends Thread{
      Account account;//账户
      //取了多少钱
      int drawingMoney;
      //现在手里有 多少钱
      int nowMoney;
      public Drawing( Account account,int drawingMoney,String name){
          super(name);
          this.account = account;
          this.drawingMoney = drawingMoney;
      }
  
      @Override
      public void run() {
          //判断有没有钱
          if(account.money-drawingMoney<0){
              System.out.println(Thread.currentThread().getName()+ "钱不够，取不了");
              return;
          }
          //sleep可以放大问题的发生性
          try {
              Thread.sleep(1000);
          } catch (InterruptedException e) {
              throw new RuntimeException(e);
          }
          //卡内余额 = 余额 - 你取的钱
          account.money = account.money - drawingMoney;
  
          //你手里的钱
          nowMoney = nowMoney + drawingMoney;
          System.out.println(account.name + "余额为" + account.money);
          //Thread.currentThread().getName() = this,getName()
          System.out.println(this.getName()+"手里的钱"+nowMoney);
      }
  }
  

案例三（List）

• package syn;
  
  
  import java.util.ArrayList;
  import java.util.List;
  
  //线程不安全的集合
  public class UnsafeList {
      public static void main(String[] args) {
          List<String> list = new ArrayList<String>();
          for (int i = 0; i < 10000; i++) {
              new Thread(()->{
                  list.add(Thread.currentThread().getName());
              }).start();
          }
          try {
              Thread.sleep(3000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println(list.size());
      }
  }
  
  

同步方法及同步块

(1)同步方法

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-whVn3Ll3-1666515575321)(F:\study\javaStudy\study\src\13.png)]
• 当操作系统没有对进程的资源进行限制时将会发生死锁。
• 方法里面需要修改的内容才需要锁，锁的太多，浪费资源。
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dVQ6fHPc-1666515575321)(F:\study\javaStudy\study\src\14.png)]

案例一（买票）

• package syn;
  
  
  //不安全的买票
  public class UnsafeBuyTicket {
      public static void main(String[] args) {
          BuyTicket station = new BuyTicket();
          new Thread(station,"苦逼的我").start();
          new Thread(station,"牛逼的你们").start();
          new Thread(station,"可恶的黄牛党").start();
      }
  }
  
  
  class BuyTicket implements Runnable{
      //票
      private  int ticketNums = 10;
      boolean flag = true;//外部停止方式
      @Override
      public void run() {
          // 买票
          while (flag) {
              try {
                  buy();
              } catch (Exception e) {
                  throw new RuntimeException(e);
              }
          }
      }
  
      //synchronized同步方法，锁的是this
      private synchronized void buy() throws InterruptedException {
          //判断是否有票
          if(ticketNums <= 0){
              flag = false;
              return;
          }
          //模拟延时
          Thread.sleep(100);
          //买票
          System.out.println(Thread.currentThread().getName()+ "拿到" + ticketNums--);
      }
  }
  

(2)同步块

案例二（取钱）

• package syn;
  
  //不安全的取钱
  //两个人去引号取钱，账户
  public class UnsafeBank {
      public static void main(String[] args) {
          //账户
          Account account = new Account(100,"结婚基金");
          Drawing you = new Drawing(account,50,"你");
          Drawing girFriend = new Drawing(account,100,"girFriend");
          you.start();
          girFriend.start();
  
      }
  }
  
  
  //账户
  class Account{
      int money;//余额
      String name;// 卡名
  
      public Account(int money, String name) {
          this.money = money;
          this.name = name;
      }
  }
  
  //银行：模拟取款
  class Drawing extends Thread{
      Account account;//账户
      //取了多少钱
      int drawingMoney;
      //现在手里有 多少钱
      int nowMoney;
      public Drawing( Account account,int drawingMoney,String name){
          super(name);
          this.account = account;
          this.drawingMoney = drawingMoney;
      }
      //synchronized 默认锁的是this
      @Override
      public void run() {
          //锁的对象就是变化的量，增删改
          synchronized (account){
              //判断有没有钱
              if(account.money-drawingMoney<0){
                  System.out.println(Thread.currentThread().getName()+ "钱不够，取不了");
                  return;
              }
              //sleep可以放大问题的发生性
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  throw new RuntimeException(e);
              }
              //卡内余额 = 余额 - 你取的钱
              account.money = account.money - drawingMoney;
  
              //你手里的钱
              nowMoney = nowMoney + drawingMoney;
              System.out.println(account.name + "余额为" + account.money);
              //Thread.currentThread().getName() = this,getName()
              System.out.println(this.getName()+"手里的钱"+nowMoney);
  
          }
  
      }
  }
  

案例三（List）

• package syn;
  
  
  import java.util.ArrayList;
  import java.util.List;
  
  //线程不安全的集合
  public class UnsafeList {
      public static void main(String[] args) {
          List<String> list = new ArrayList<String>();
          for (int i = 0; i < 10000; i++) {
              new Thread(()->{
                  synchronized (list){
                      list.add(Thread.currentThread().getName());
                  }
              }).start();
          }
          try {
              Thread.sleep(3000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println(list.size());
      }
  }
  
  

CopyOnWriteArrayList

• package syn;
  
  import java.util.concurrent.CopyOnWriteArrayList;
  
  //测试JUC安全类型的集合
  public class TestJUC {
      public static void main(String[] args) {
          CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
          for (int i = 0; i < 10000; i++) {
              new Thread(()->{
                  list.add(Thread.currentThread().getName());
              }).start();
          }
          try {
              Thread.sleep(3000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println(list.size());
      }
  }
  
  

5. 死锁

• 索格线程各自占有一些共享资源，并且相互等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。

• package syn;
  
  //死锁：多个线程互相抱着对方需要的资源，然后相互僵持
  public class DeadLock {
      public static void main(String[] args) {
          Makeup g1 = new Makeup(0,"灰姑娘");
          Makeup g2 = new Makeup(1,"白雪公主");
          g1.start();
          g2.start();
      }
  }
  
  //口红
  class Lipstick{
  
  }
  
  //镜子
  class Mirror{
  
  }
  
  class Makeup extends  Thread{
      //需要的资源只有一份,用static来保证只有一份
      static Lipstick lipstick = new Lipstick();
      static Mirror mirror = new Mirror();
  
      int choice;//选择
      String girName;//使用化妆品的人
  
      Makeup(int choice,String girName){
          this.choice = choice;
          this.girName = girName;
      }
      @Override
      public void run() {
          super.run();
          //化妆\
          try {
              makeup();
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
      //化妆，互相持有对方的锁，就是需要拿到对方的资源
      private void makeup() throws InterruptedException {
          if(choice == 0){
              synchronized (lipstick){//获得口红的锁
                  System.out.println(this.girName+ "获得口红的锁");
                  Thread.sleep(1000);
  //                synchronized (mirror){//一秒钟后想获得镜子
  //                    System.out.println(this.girName+ "获得镜子的锁");
  //                }
          }
              synchronized (mirror){//一秒钟后想获得镜子
                      System.out.println(this.girName+ "获得镜子的锁");
                  }
      }
          else {
              synchronized (mirror) {//获得镜子的锁
                  System.out.println(this.girName + "获得镜子的锁");
                  Thread.sleep(2000);
  //                synchronized (lipstick) {//2秒钟后想获得口红
  //                    System.out.println(this.girName + "获得镜子的锁");
  //                }
              }
              synchronized (lipstick) {//2秒钟后想获得口红
                      System.out.println(this.girName + "获得镜子的锁");
                  }
          }
      }
  
  }
  

• 产生死锁的四个必要条件：

  1. 互斥条件：一个资源每次只能被一个进程使用
  2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
  3. 不剥夺条件：进程已获得的资源，在未使用之前，不能强行剥夺。
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

• 上面列出了死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生。

6. Lock（锁）

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QxUPO2rA-1666515575321)(F:\study\javaStudy\study\src\15.png)]

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aud4waYN-1666515575321)(F:\study\javaStudy\study\src\16.png)]

• package syn;
  
  import java.util.concurrent.locks.ReentrantLock;
  
  //测试Lock锁
  public class TestLock {
      public static void main(String[] args) {
          TestLock2 testLock2 = new TestLock2();
  
          new Thread(testLock2).start();
          new Thread(testLock2).start();
          new Thread(testLock2).start();
      }
  }
  
  
  class TestLock2 implements Runnable{
      int ticketNums = 10;
  
      //定义lock锁
      private  final ReentrantLock lock = new ReentrantLock();
  
  
      @Override
      public void run() {
          while (true){
  
  
              try {
                  lock.lock();//加锁
                  if (ticketNums>0){
                      try {
                          Thread.sleep(1000);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                      System.out.println(ticketNums--);
                  }else{
                      break;
                  }
              } finally {
                  lock.unlock();
              }
          }
      }
  }
  

synchronized 与Lock的对比

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qi2gU78S-1666515575322)(F:\study\javaStudy\study\src\17.png)]

7. 线程协作

生产者消费者

• 生产者消费者（producer-consumer）（有界缓冲区（bounded-buffer））模式

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pa3DZKSy-1666515575322)(F:\study\javaStudy\study\src\18.png)]

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FZg6tIQC-1666515575322)(F:\study\javaStudy\study\src\19.png)]

线程通信-分析

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lEnmswkq-1666515575323)(F:\study\javaStudy\study\src\20.png)]

解决方式1（管程法）

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bVLpfTWX-1666515575323)(F:\study\javaStudy\study\src\21.png)]

• package syn;
  
  
  //测试：生产者消费者模型---》 利用缓冲区解决：管程法
  
  //生产者，消费者，产品，缓冲区
  public class TestPC {
      public static void main(String[] args) {
          SynContainer container = new SynContainer();
          new Productor(container).start();
          new Consumer(container).start();
  
      }
  
  }
  
  //生产者
  class  Productor extends  Thread{
      SynContainer container;
      public Productor(SynContainer container){
          this.container = container;
      }
  
      //生产
  
      @Override
      public void run() {
  
          for (int i = 0; i < 100; i++) {
              container.push(new Chicken(i));
              System.out.println("生产了"+i+"只鸡");
          }
      }
  }
  
  //消费者
  class Consumer extends Thread{
      SynContainer container;
      public Consumer(SynContainer container){
          this.container = container;
      }
      //消费
  
      @Override
      public void run() {
          for (int i = 0; i < 100; i++) {
              System.out.println("消费了----》" + container.pop().id+"只鸡");
          }
      }
  }
  
  //产品
  
  class Chicken{
      int id;//产品编号
  
      public Chicken(int id) {
          this.id = id;
      }
  }
  
  //缓冲区
  
  class  SynContainer{
      //需要一个容器大小
      Chicken[] chickens = new Chicken[10];
      //容器计数器
      int count = 0;
      //生产者放入产品
      public  synchronized void push(Chicken chicken){
          //如果容器满了，就需要等待消费这消费
          if(count == chickens.length){
              //通知消费者消费，生产者等待
              try {
                  this.wait();
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
  
          //如果没有满，我们就需要丢入产品
          chickens[count] = chicken;
          count++;
          //可以通知消费者消费了
          this.notifyAll();
      }
  
      //消费者消费产品
      public  synchronized  Chicken pop(){
          //判断能否消费
          if(count==0){
              //等待生产者生产。消费者等待
              try {
                  this.wait();
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
          //如果可以消费
          count--;
          Chicken chicken = chickens[count];
  
          //吃完了，通知生产生产
          this.notifyAll();
          return chicken;
      }
  }
  

解决方式2（信号灯法）

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1HmsgBmz-1666515575323)(F:\study\javaStudy\study\src\22.png)]

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zxZk6LkH-1666515575323)(F:\study\javaStudy\study\src\23.png)]package syn;
  
  //测试生产者问题2：信号灯法，标志位解决
  public class TestPC2 {
      public static void main(String[] args) {
          Tv tv = new Tv();
          new Player(tv).start();
          new Watcher(tv).start();
      }
  }
  
  //生产者--》演员
  class  Player extends Thread{
      Tv tv;
      public Player(Tv tv){
          this.tv = tv;
      }
  
      @Override
      public void run() {
          for (int i = 0; i < 20; i++) {
              if(i%2==0){
                  this.tv.play("快乐大本营");
              }else{
                  this.tv.play("抖音");
              }
          }
      }
  }
  
  
  //消费者---》观众
  class Watcher extends Thread{
      Tv tv;
      public Watcher(Tv tv){
          this.tv = tv;
      }
  
      @Override
      public void run() {
          for (int i = 0; i < 20; i++) {
              tv.watch();
          }
      }
  }
  
  
  //产品---》节目
  class  Tv{
      //演员表演观众等待
      //观众观看演员等待
      String voice;//表演节目
      boolean flag = true;
  
      //表演
      public synchronized void play(String voice){
          if(!flag){
              try {
                  this.wait();
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
          System.out.println("演员表演了"+voice);
          //通知观众观看
          this.notify();
          this.voice = voice;
          this.flag =  !this.flag;
      }
  
      //观看
      public  synchronized void watch(){
          if(flag){
              try {
                  this.wait();
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
          System.out.println("观看了"+voice);
          //通知演员表演
          this.notify();
          this.flag =  !this.flag;
      }
  }
  

8. 线程池

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O23G4jPU-1666515575323)(F:\study\javaStudy\study\src\23.png)]

• 使用线程迟

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZbWHuRST-1666515575324)(F:\study\javaStudy\study\src\24.png)]

• package syn;
  
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  
  public class TestPool {
      public static void main(String[] args) {
          //1, 创建服务，创建线程池
          // newFixedThreadPool 参数为：线程池大小
          ExecutorService service = Executors.newFixedThreadPool(10);
          service.execute(new MyThread());
          service.execute(new MyThread());
          service.execute(new MyThread());
          service.execute(new MyThread());
          //2.关闭链接
          service.shutdown();
      }
  }
  
  class  MyThread implements  Runnable{
      @Override
      public void run() {
          System.out.println(Thread.currentThread().getName());
      }
  }
  

总结：

• package syn;
  
  
  import java.util.concurrent.Callable;
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.FutureTask;
  
  //回顾总结线程的创建
  public class ThreadNew {
      public static void main(String[] args) {
          new MyThread1().start();
          new Thread(new MyThread2()).start();
  
          FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());
          new Thread(futureTask).start();
          try {
              Integer integer =  futureTask.get();
              System.out.println(integer);
          } catch (InterruptedException e) {
              e.printStackTrace();
          } catch (ExecutionException e) {
              e.printStackTrace();
          }
      }
  }
  
  //1，继承Thread类
  class  MyThread1 extends Thread{
      @Override
      public void run() {
          System.out.println("My Thread1");
      }
  }
  
  
  //2. 实现RUnnable接口
  class  MyThread2 implements  Runnable{
      @Override
      public void run() {
          System.out.println("My Thread2");
      }
  }
  
  //3. 实现callable接口
  class MyThread3 implements Callable<Integer>{
      @Override
      public Integer call() throws Exception {
          System.out.println("My Thread3");
          return 100;
      }
  }
  

二. javaWEB

1. 数据库(MySQL)

• 注册Mysql服务

  • mysql -install

• 启动mysql

  • net start mysql

• 停止mysql

  • net stop mysql

• 修改默认账户密码

  • mysqladmin -u root password 1234

• 登录mysql

  • mysql -uroot -p1234

• 退出mysql

  • exit/quit

• 登录参数

  • mysql -u用户名 -p密码 -h要连接mysql的ip地址 -P端口号（3306）

• 卸载mysql

  • mysqld -remove mysql

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mzJpr8pW-1666515575324)(F:\study\javaStudy\study\src\25.png)]

聚合函数

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NWs56rMC-1666515575324)(F:\study\javaStudy\study\src\26.png)]

分页查询

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HrXoaDbz-1666515575324)(F:\study\javaStudy\study\src\27.png)]

约束

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vwgZw01C-1666515575324)(F:\study\javaStudy\study\src\28.png)]

外键

• 概念：外键用来让两个表的数据之间建立链接，保证数据的一致性和完整性。

• 语法：

  1. 添加约束

     • -- 创建表时添加外键约束
       CREATE TABLE 表名{
       	列名 数据类型，
       	……
       	[CONSTRAINT][外键名称] FOREIGN KEY(外键列名) REFERENCES 主表（主表列名）
       };
       

     • -- 建完表后添加外键约束
       ALTER TABLE 表名 ADD CONSTRAINT 外键名称 FOREIGN KEY（外键字段名称) REFERENCES主表名称(主表列名称);
       

  2. 删除约束

     • ALTER TABLE表名 DROP FOREIGN KEY 外键名称;
       

数据库设计

1. 软件的研发步骤
   • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z9KQPH58-1666515575325)(F:\study\javaStudy\study\src\29.png)]
2. 数据库设计概念
   • 数据库设计就是根据业务系统的具体需求，结合我们所选用的DBMS,为这个业务系统构造出最优的数据存储模型。
   • 建立数据库中国的 表结构 以及 表与表之间的关联关系 的过程
   • 有那些表？表里有那些字段？表和表之间有什么关系？
3. 数据设计的步骤
   1. 需求分析（数据是什么？数据具有那些属性？数据与属性的特点是什么）
   2. 逻辑分析（通过ER图对数据库进行逻辑建模，不需要考虑我们所选用的数据库管理系统)
   3. 物理设计（根据数据库自身的特点把逻辑设计转换为物理设计)
   4. 维护设计（1.对新的需求进行建表;2.表优化)
4. 表关系
   • 一对一
   • 一对多（多对一）
   • 多对多

多表查询（笛卡尔积）

• 笛卡尔积:有A,B两个集合取A,B所有的组合情况（有无效数据）

• 消除无效数据

• 连接查询

  • 内连接：相当于查询A B交集数据

    • --隐式内连接
      SELECT 字段列表 FROM表1,表2... WHERE条件;
      --显示内连接
      SELECT字段列表FROM 表1[INNER]JOIN 表2 ON条件;
      

  • 外连接

    • 左外连接：相当于查询A表所有数据和交集部分数据

    • 右外连接：相当于查询B表所有数据和交集部分数据

    • --左外连接
      SELECT字段列表FROM表1 LEFT [ouTER] JOIN 表2 ON条件;
      -右外连接
      SELECT字段列表FROM表1 RIGHT [OUTER] JOIN 表2 ON条件;
      

  • 子查询

    • 子查询概念:

      • 查询中嵌套查询，称嵌套查询为子查询

    • 子查询根据查询结果不同，作用不同:

      • 单行单列
      • 多行单列·多行多列

    • 子查询根据查询结果不同，作用不同：

      • 单行单列:作为条件值，使用=!= ><等进行条件判断

      • SELECT字段列表FROM 表 wHERE 字段名 = (子查询);
        

      • 多行单列:作为条件值，使用in等关键字进行条件判断

      • SELECT字段列表 FROM 表 WHERE 字段名  in (子查询);
        

      • 多行多列:作为虚拟表

      • SELECT字段列表 FROM(子查询)WHERE条件;
        

事务

• 事务简介

  • 数据库的事务(Transaction)是一种机制、一个操作序列，包含了一组数据库操作命令
  • 事务把所有的命令作为一个整体一起向系统提交或撤销操作请求，即这一组数据库命令要么同时成功，要么同时失败
  • 事务是一个不可分割的工作逻辑单元

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j0O7CRDk-1666515575325)(F:\study\javaStudy\study\src\30.png)]

• 事务四大特征

  • 原子性(Atomicity):事务是不可分割的最小操作单位，要么同时成功，要么同时失败
  • 一致性(Consistency):事务完成时，必须使所有的数据都保持一致状态
  • 隔离性(lsolation) :多个事务之间，操作的可见性
  • 持久性(Durability):事务一旦提交或回滚，它对数据库中的数据的改变就是永久的

• MySQL事务默认自动提交

  • --查看事务的默认提交方式
    SELECT @@autocommit;
    -- 1自动提交 0手动提交
    --修改事务提交方式
    set @@autocommit = 0;
    

2. JDBC

• JDBC就是使用Java语言操作关系型数据库的一套API

• //1.注册非动
  class.forName ( "com.mysql.jdbc.Driver" );
  //2.获取连接对象
  String url = "jdbc :mysql://127.0.0.1:3306/db1?usesSL=false" ;
  String username = "root";
  String password = "1234";
  Connection conn = DriverHanager.getConnection(url,username,password);
  //3．定义SQL
  string sql = "update account set money = 2000 where id = 1";
  //4．获取执行sql的对象
  statement stmt = conn.createstatement();
  //5.执行sql
  int count = stmt.executeUpdate(sql);
  // 6.处理结果
  // System.out.println(count) ;
  //7．释放资源
  stmt.close();
  conn.close();
  

• JDBC概念

  • JDBC就是使用java语言操作关系型数据库的一套API

  • 全称（Java DataBase Connectivity）Java数据库连接

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XmAlinsf-1666515575325)(F:\study\javaStudy\study\src\31.png)]

  • 步骤

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z82c1ko1-1666515575325)(F:\study\javaStudy\study\src\32.png)]

  • package com.zjxweb;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.Statement;
    
    public class JDBCDemo {
        public static void main(String[] args) throws Exception {
            //1. 注册驱动
            //Class.forName("com.mysql.jdbc.Driver");
    
            //2. 获取连接
            String url="jdbc:mysql://127.0.0.1:3306/db1";
            String username="root";
            String password= "123456";
            Connection conn =  DriverManager.getConnection(url,username,password);
    
            //3. 定义sql语句
            String sql = "update db set sum = 2 where id=8";
    
            //4. 获取执行sql的对象 Statement
            Statement stmt = conn.createStatement();
    
            //5. 执行sql
            int count = stmt.executeUpdate(sql);//影响的行数
    
            //6. 处理结果
            System.out.println(count);
    
            //7.释放资源
            stmt.close();
            conn.close();
        }
    }
    

（1） JDBC API详解

Driver Manager

• DriverManager(驱动管理类)作用:

  • 注册驱动
  • 获取数据库连接

• 获取连接

  • static Connection getConnection (string url,string user,string password)

  • 参数

    1. url：连接参数

       语法: jdbc:mysql:/lip地址(域名):端口号/数据库名称?参数键值对1&参数键值对2...
       示例: jdbc:mysql://127.0.0.1:3306/db1
       细节:
       ·如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为:jdbc:mysql:///数据库名称?参数键值对
       ·配置usesSL=false参数，禁用安全连接方式，解决警告提示
       
       String url="jdbc:mysql://127.0.0.1:3306/db1?useSSL=false";
       

    2. user：用户名

    3. password：密码

Connection

• Connection(数据库连接对象)作用:

  • 获取执行SQL的对象

    • 普通执行sql对象
    • Statement createStatement()
    • 预编译SQL的执行SQL对象：防止SQL注入
    • PreparedStatement prepareStatement (sql)
    • 执行存储过程的对象
    • CallableStatement prepareCall (sql)

  • 管理事务

    • Mysql事务管理

      • 开启事务:BEGIN; /STARTTRANSACTION;
        提交事务:COMMIT;
        回滚事务:ROLLBACK;
        MYSQL默认白动提交事冬
        

      • JDBC事务管理：Connection接口中定义了3个对应的方法

      • 开启事务: setAutoCommit(boolean autoCommit): true为自动提交事务;false为手动提交事务，即为开启事务
        提交事务:commit()
        回滚事务:rollback()
        

  • package com.zjxweb;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    public class JDBCDemo {
        public static void main(String[] args) throws Exception {
            //1. 注册驱动
            Class.forName("com.mysql.jdbc.Driver");
    
            //2. 获取连接
            String url="jdbc:mysql://127.0.0.1:3306/db1?useSSL=false";
            String username="root";
            String password= "123456";
            Connection conn =  DriverManager.getConnection(url,username,password);
    
            //3. 定义sql语句
            String sql = "update db set sum = 2 where id=8";
            String sql1 = "update db set sum = 2 where id=9";
    
            //4. 获取执行sql的对象 Statement
            Statement stmt = conn.createStatement();
    
            try {
                //开启事务
                conn.setAutoCommit(false);
                //5. 执行sql
                int count = stmt.executeUpdate(sql);//影响的行数
                System.out.println(count);
                int count1 = stmt.executeUpdate(sql1);//影响的行数
    
                //6. 处理结果
    
                System.out.println(count1);
    
                //提交事务
                conn.commit();
            } catch (Exception e) {
                conn.rollback();
            }
    
    
            //7.释放资源
            stmt.close();
            conn.close();
        }
    }
    
    

Statement

• Statement作用

  • 执行sql语句

  • int executeUpdate(sql):执行DML、DDL语句
    返回值: (1)DML语句影响的行数(2) DDL语句执行后，执行成功也可能返回0
    

  • ResultSet executeQuery(sql):执行DQL语句
    返回值: ResultSet结果集对象
    

ResultSet

• ResultSet（结果集对象）作用：

  • 封装了DQL查询语句的结果

  • ResultSet stmt.executeQuery(sql):执行DQL语句，返回ResultSet对象
    

• 获取查询结果

  • boolean next(): (1)将光标从当前位置向前移动一行(2）判断当前行是否为有效行
    返回值:
    true:有效行，当前行有数据 
    false:无效行，当前行没有数据
    

  • xXx getXxx(参数):获取数据
    xXx:数据类型;如:int getInt(参数) ; String getString(参数)
    参数:
    . int:列的编号，从1开始
    . String: 列的名称
    

• 使用步骤

  1. 游标向下移动一行，并判断该行是否有数据：next()
  2. 获取数据：getXxx（参数）

  • //循环判断游标是否是最后一行末尾
    while(rs.next()){
    	//获取数据
    	rs.getXxx(参数);
    }
    

  • package com.zjxweb;
    
    import java.sql.*;
    
    public class JDBCDemo1 {
        public static void main(String[] args) throws Exception {
            //1. 注册驱动
            Class.forName("com.mysql.jdbc.Driver");
    
            //2. 获取连接
            String url="jdbc:mysql://127.0.0.1:3306/db1?useSSL=false";
            String username="root";
            String password= "123456";
            Connection conn =  DriverManager.getConnection(url,username,password);
    
            //3. 定义sql语句
            String sql = "select * from db";
    
            //4. 获取执行sql的对象 Statement
            Statement stmt = conn.createStatement();
    
            //5.指向SQL
            ResultSet rs = stmt.executeQuery(sql);
            //6. 处理结果。遍历rs中的所有数据
            //6.1 光标向下移动一行，并且判断当前行是否有数据
            while(rs.next()){
                //6.2 获取数据
                String data = rs.getString(1);
                String name = rs.getString(2);
                String local = rs.getString(3);
                System.out.println(data);
                System.out.println(name);
                System.out.println(local);
                System.out.println("---------------");
            }
            //释放资源
            rs.close();
            stmt.close();
            conn.close();
        }
    }
    

  • 案例

    • 记得重写toString（）方法

  • package com.zjxweb.pojo;
    
    public class Account {
        private String data;
        private String name;
        private String local;
    
        public String getData() {
            return data;
        }
    
        public void setData(String data) {
            this.data = data;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getLocal() {
            return local;
        }
    
        public void setLocal(String local) {
            this.local = local;
        }
    //    public String toString(){
    //        return data+name+local;
    //    }
    
        @Override
        public String toString() {
            return "Account{" +
                    "data='" + data + '\'' +
                    ", name='" + name + '\'' +
                    ", local='" + local + '\'' +
                    '}';
        }
    }
    
    

  • package com.zjxweb;
    
    import com.zjxweb.pojo.Account;
    
    import java.sql.*;
    import java.util.ArrayList;
    import java.util.List;
    
    
    /**
     * 查询account账户表数据，封装为Account对象中，兵并且存储到ArratList集合中
     * 1. 定义实体类Account
     * 2. 查询数据，封装到Account对象中
     * 3. 将Account对象存入ArrayList集合中
     */
    
    public class JDBCDemo1 {
    
    
        public static void main(String[] args) throws Exception {
            //1. 注册驱动
            Class.forName("com.mysql.jdbc.Driver");
    
            //2. 获取连接
            String url="jdbc:mysql://127.0.0.1:3306/db1?useSSL=false";
            String username="root";
            String password= "123456";
            Connection conn =  DriverManager.getConnection(url,username,password);
    
            //3. 定义sql语句
            String sql = "select * from db";
    
            //4. 获取执行sql的对象 Statement
            Statement stmt = conn.createStatement();
    
            //5.指向SQL
            ResultSet rs = stmt.executeQuery(sql);
    
            //创建集合
            List<Account> list = new ArrayList<>();
    
    
            //6. 处理结果。遍历rs中的所有数据
            //6.1 光标向下移动一行，并且判断当前行是否有数据
            while(rs.next()){
                Account account = new Account();
                //6.2 获取数据
                String data = rs.getString(1);
                String name = rs.getString(2);
                String local = rs.getString(3);
                //赋值
                account.setData(data);
                account.setName(name);
                account.setLocal(local);
    
                //存入集合
                list.add(account);
            }
            System.out.println(list);
            //释放资源
            rs.close();
            stmt.close();
            conn.close();
        }
    }
    
    

PreparedStatement

• PreparedStatement作用

  • 预编译SQL语句并执行：预防SQL注入问题

• SQL注入

  • SQL注入是通过操作输入来修改事先定义好的SQL语句，用以达到执行代码对服务器进行 攻击 的方法。

• 案列

• package com.zjxweb;
  
  import java.sql.Connection;
  import java.sql.DriverManager;
  import java.sql.ResultSet;
  import java.sql.Statement;
  
  public class JDBCDemo6_UserLogin {
      public static void main(String[] args) throws Exception {
          //1. 注册驱动
          Class.forName("com.mysql.jdbc.Driver");
  
          //2. 获取连接
          String url="jdbc:mysql://127.0.0.1:3306/db1?useSSL=false";
          String username="root";
          String password= "123456";
          Connection conn =  DriverManager.getConnection(url,username,password);
  
          String name = "zhanshan";
  //        String pwd = "123456";
          String pwd = "' or ' 1 '= ' 1 ";
          String sql = "select * from tb_user where username = '"+name+"' and password = '"+pwd+"'";
  
  //        获取stmt对象
          Statement stmt = conn.createStatement();
  
          //执行sql
          ResultSet rs = stmt.executeQuery(sql);
  
          //判断登录是否成功
          if(rs.next()){
              System.out.println("登录成功");
          }else {
              System.out.println("登录失败");
          }
          //7.释放资源
          rs.close();
          stmt.close();
          conn.close();
      }
  }
  

• 解决sql注入问题

  1. 获取PreparedStatement对象

     • // SQL语句中的参数值，使用?占位符替代
       String sql = "select * from user where username = ? and password = ?";
       //通过Connection对象获取，并传入对应的sql语句
       PreparedStatement pstmt = conn.prepareStatement(sql);
       
       

  2. 设置参数值

     • PreparedStatement对象: setXxx(参数1，参数2):给﹖赋值
       Xxx:数据类型;如setlnt(参数1，参数2)
       参数:
       	参数1:?的位置编号，从1开始
           参数2:?的值
       
       

  3. 执行SQL

     • executeUpdate(); // executeQuery();:不需要再传递sql
       

• 案列

  • package com.zjxweb;
    
    import java.sql.*;
    
    public class JDBCDemo6_UserLogin {
        public static void main(String[] args) throws Exception {
            //1. 注册驱动
            Class.forName("com.mysql.jdbc.Driver");
    
            //2. 获取连接
            String url="jdbc:mysql://127.0.0.1:3306/db1?useSSL=false";
            String username="root";
            String password= "123456";
            Connection conn =  DriverManager.getConnection(url,username,password);
    
            String name = "zhanshan";
            String pwd = "123456";
    //        String pwd = "' or ' 1 '= ' 1 ";
    //        String sql = "select * from tb_user where username = '"+name+"' and password = '"+pwd+"'";
            String sql = "select * from tb_user where username = ? and password = ?";
    
    //        获取stmt对象
            PreparedStatement pstmt = conn.prepareStatement(sql);
    
    //        设置 ？ 的值
            pstmt.setString(1,name);
            pstmt.setString(2,pwd);
    
            //执行sql
            ResultSet rs = pstmt.executeQuery();
    
            //判断登录是否成功
            if(rs.next()){
                System.out.println("登录成功");
            }else {
                System.out.println("登录失败");
            }
            //7.释放资源
            rs.close();
            pstmt.close();
            conn.close();
        }
    }
    

  • PreparedStatement原理

    • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TAGkBC0k-1666515575325)(F:\study\javaStudy\study\src\33.png)]

    • log-output=FILE
      general-log=1
      general_log_file="D:\mysql.log"
      slow-query-log=1
      slow_query_log_file="D:\mysql_slow.log"
      long_query_time=2
      

（2） 数据库连接池

数据库连接池简介

• 数据库连接池 是个容器，负责分配、管理数据库连接（Connection）

• 它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个;

• 释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏好处:

  • 资源重用。
  • 提升系统响应速度。
  • 避免数据库连接遗漏

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9HM1yXSU-1666515575326)(/34.png)]

• 数据库连接池实现

  • 标准接口： DataSource
    • 官方(SUN)提供的数据库连接池标准接口，由第三方组织实现此接口。
    • 功能:获取连接
  • Connection getConnection()
  • 常见的数据库连接池
    • DBCP
    • C3P0
    • Druid
  • Druid（德鲁伊）
    • Druid连接池是阿里巴巴开源的数据库连接池项目
    • 功能强大，性能优秀，是Java语言最好的数据库连接池之一

• Druid使用步骤

  1. 导入jar包,druid-1.1.12.jar
  2. 定义配置文件
  3. 加载配置文件
  4. 获取数据库连接池对象
  5. 获取连接

3. Maven

• Maven是专门用于管理和构建Java项目的工具，它的主要功能有:
  • 提供了一套标准化的项目结构
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jt6Lbr3V-1666515575326)(/35.png)]
  • 提供了一套标准化的构建流程(编译，测试，打包，发布…)
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ps7h0TOJ-1666515575326)(/36.png)]
    • Maven提供了一套简单的命令来完成项目构建
  • 提供了一套依赖管理机制
    • 依赖管理
      • 依赖管理其实就是管理你项目所依赖的第三方资源(jar包、插件…)
      • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SdEPUh04-1666515575326)(/37.png)]
• Maven 提供了一套标准化的项目结构，所有IDE使用Maven构建的项目结构完全一样，所有IDE创建的Maven项目可以通用
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PaoJLSV2-1666515575326)(/38.png)]

(1) Maven安装配置

1. 解压apache-maven-3.6.1.rar既安装完成

2. 配置环境变量MAVEN_HOME为安装路径的bin目录

3. 配置本地仓库:修改conf/settings.xml中的为一个指定目录

4. 配置阿里云私服:修改conf/settings.xml中的标签，为其添加如下子标签:

   • <mirror>
         <id>alimavenid>
         <name>aliyun mavenname>
         <url>http://maven.aliyun.com/nexus/content/groups/public/url>
         <mirrorOf>centralmirrorOf>
     mirror>
     

(2) Maven 基本命令

• compile :编译
• clean:清理
• test:测试
• package:打包
• install:安装

(3) Maven生命周期

• Maven构建项目生命周期描述的是一次构建过程经历经历了多少个事件
• Maven对项目构建的生命周期划分为3套
  • clean:清理工作
  • default:核心工作，例如编译，测试，打包，安装等
  • site: 产生报告，发布站点等
• 同一生命周期内，执行后边的命令，前面的所有命令会自动执行
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m6VNZ1ik-1666515575326)(/39.png)]

(4)IDEA配置Maven

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DzoGx9a0-1666515575327)(/40.png)]

Maven坐标详解

1. 什么是坐标?

• Maven 中的坐标是资源的唯一标识
• 使用坐标来定义项目或引入项目中需要的依赖

2. Maven坐标主要组成

   • groupld:定义当前Maven项目隶属组织名称(通常是域名反写,例如: com.itheima)
   • artifactld:定义当前Maven项目名称(通常是模块名称，例如order-service、goods-service)
   • version:定义当前项目版本号

3. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6dwrhZK8-1666515575327)(/41.png)]

4. 使用坐标导入jar包

   1. 在pom.xml中编写标签
   2. 在标签中使用引入坐标
   3. 定义坐标的groupld,artifactld,version
   4. 点击刷新按钮，使坐标生效

5. 自动导入

   1. 选择IDEA中File --> Settings
   2. 在弹出的面板中找到Build Tools
   3. 选择Any changes，点击ok即可生效

依赖范围

• 通过设置坐标的依赖范围（scope），可以设置对应jar包的作用范围：编译环境、测试环境、运行环境
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3gIFqggX-1666515575327)(/42.png)]
• 默认值：compile

4. MyBatis

• 什么是mybatis
  • MyBatis是一款优秀的持久层框架，用于简化JDBC 开发
    MyBatis本是 Apache的一个开源项目iBatis, 2010年这个项目由apache softwarefoundation迁移到了google code，并且改名为MyBatis。2013年11月迁移到Github
  • 官网: https://mybatis.org/mybatis-3/zh/index.html
• 持久层
  • 负责将数据到保存到数据库的那一层代码
  • JavaEE三层架构:表现层、业务层、持久层
• 框架
  • 框架就是一个半成品软件，是一套可重用的、通用的、软件基础代码模型
  • 在框架的基础之上构建软件编写更加高效、规范、通用、可扩展
• JDBC缺点
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LxEkozF5-1666515575327)(/43.png)]
• MyBatis简化
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-geBkByHd-1666515575327)(/44.png)]

MyBatis快速入门

• 查询user表中所有数据
  1. 创建user表，添加数据
  2. 创建模块，导入坐标
  3. 编写MyBatis核心配置文件–>替换连接信息解决硬编码问题
  4. 编写SQL映射文件–>统一管理sql语句，解决硬编码问题
  5. 编码
     1. 定义POJO类
     2. 加载核心配置文件，获取SqlSessionFactory 对象
     3. 获取SqlSession对象，执行SQL语句
     4. 释放资源

解决SQL映射文件的警告提示

• 产生原因：Idea和数据库没有建立连接，不识别表信息
• 解决方式：在Idea中设置MySQL数据库连接
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6ZsGe7F2-1666515575327)(/45.png)]

Mapper代理开发

• 目的
  • 解决原生方式中的硬编码
  • 简化后期执行SQL
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zTzwMplA-1666515575328)(/46.png)]
• 使用Mapper代理步骤
  1. 定义与SQL映射文件同名的Mapper接由，并且将Mapper接口和SQL映射文件放置在同一目录下
     • 命名的时候记得用“/”作为分隔符
  2. 设置SQL映射文件的namespace属性为Mapper接口全限定名
  3. 在Mapper接口中定义方法，方法名就是SQL映射文件中sql语句的id，并保持参数类型和返回值类型一致
  4. 编码
     1. 通过SqlSession的getMapper方法获取Mapper接口的代理对象
     2. 调用对应方法完成sql的执行
• 细节：如果Mapper接口名称和SQL映射文件名称相同，并在同一目录下，则可以使用包扫描的方式简化SQL映射文件的加载。
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jscuzemm-1666515575328)(/47.png)]
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OK0krFP4-1666515575328)(/48.png)]

Mybatis核心配置 文件

• environments:配置数据库连接环境信息。可以配置多个environment，通过default属性切换不同的environment

• MyBatis核心配置文件的顶层结构如下:

  • configuration(配置)

    • properties(属性)

    • settings(设置)

    • otypeAliases(类型别名)

    • typeHandlers(类型处理器)

    • objectFactory (对象工厂)o

    • plugins (插件)

    • oenvironments(环境配置)

      • environment(环境变量)

      • transactionManager (事务管理器)-

      • dataSource(数据源)

      • databaseldProvider (数据库厂商标识)

      • mappers(映射器)

  • 设置别名（typeAliases）

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6iIRvhwO-1666515575328)(/49.png)]

  • 细节：配置各个标签时，需要遵守前后顺序

查询名字不一致问题解决

• 数据库表的字段名称―和―实体类的属性名称不一样，则不能自动封装数据
  *起别名:对不一样的列名起别名，让别名和实体类的属性名一样
  *缺点:每次查询都要定义一次别名
  	*sql片段
  * resultMap
  	1．定义标签
  	2．在标签中，使用resultMap属性替换resultType属性
    
     
   
  <sql id="brand_column">
  	id,brand_name as brandName，company_name as companyName，ordered,description，status</sql>
  <select id="selectAll" resultType="brand" >
  <select
  	<include refid="brand_column"/>from tb_brand;
  </select>
   
   
     
   
  resultMap
   
      
   
       
   
  <resultMap id=" brandResultMap" type="brand">
  	<result column="brand_name" property="brandName"/>
  	<result column="company_name" property="companyName"/></resultMap>
  <select id="selectAll" resultMap="brandResultHapl">
  	<select
  	*
  	from tb_brand;
  </select>
   
   
       
   
  id:唯一标识
   
   
       
   
  type：映射的类型，支持别名
   
        
   
         
  id:完成主键字段的映射 
          
   
           
  column:表的列名
   
           
  property:实体类的属性名
   
          
   
   
         
  result:完成一般字段的映射 
          
   
           
  column:表的列名
   
           
  property:实体类的属性名
   
          
   
   
        
   
   
      
   
   
     
    
  参数占位符
   
    
   
     
   
  #{ }∶会将其替换为?，为了防止SQL注入
   
   
     
   
  ${}:拼sql。会存在SQL注入问题
   
   
     
   
  使用时机:
   
      
   
       
  *参数传递的时候:#{}
   
       
  *表名或者列名不固定的情况下:${科会存在SQL注入问题
   
      
   
   
     
   
  参数类型：parameterType:可以省略
   
      
   
       
   
  <select id="selectById"resultMap= "brandResultMap" parameterType="int">
  	select *
  	from tb_brand where id = #{id};
  </select>
   
   
      
   
   
     
   
  特殊字符处理：
   
      
   
       
   
  转义字符
   
   
       
   
  CDATA区
   
        
   
         
   
  <select id="selectById"resultMap= "brandResultMap">
  	select *
  	from tb_brand where id
      <![CDATA[
          <
  	1I]]>
      #{id};
  </select>
  
   
   
        
   
   
      
   
   
    
   
    
  条件查询
   
    
   
     
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ZbwcH3d-1666515575328)(/50.png)]
   
     
  SQL语句设置多个参数有几种方式? 
      
   
       
  1**)散装参数**:需要使用@Param(“sQL中的参数占位符名称”)
   
       
  2)实体类封装参数 
        
   
         
  *只需要保证sQL中的参数名和实体类属性名对应上，即可设置成功
   
        
   
   
       
  map集合 
        
   
         
  *只需要保证sQL中的参数名和map集合的键的名称对应上，即可设置成功
   
        
   
   
      
   
   
    
   
    
  动态条件查询
   
    
   
     
   
  多条件
   
      
   
       
   
  SQL语句会随着用户的输入或外部条件的变化而变化，我们称为动态SQL
   
   
       
   
  <select id="selectByCondition" resultMap="brandResultMap">
    select *
    from tb_brandwhere
    status = #{status}
    and company_name like #{companyName}and brand_name like #{brandName}
  </select>
   
   
       
   
  MyBatis对动态SQL有很强大的支撑:
   
        
   
         
   
  if:条件判断
   
          
   
           
   
  test：逻辑表达式
   
   
           
   
  问题
   
            
   
             
  恒等式（1=1）
   
             
   替换 where 关键字
   
            
   
   
           
   
    <select id="selectByCondition" resultMap="brandResultMap">
        <where>
            select *
            from tb_brand where
            <if test="status != null">
                status = #{status}
            </if>
            <if test="companyName != null and companyName != '' ">
                and company_name like #{companyName}
            </if>
            <if test="brandName != null and brandName != '' ">
                and brand_name like #{brandName}
            </if>
        </where>
    </ select>
   
   
          
   
   
         
   
  choose (when, otherwise)
   
   
         
   
  trim (where, set)
   
   
         
   
  foreach
   
   
        
   
   
      
   
   
     
   
  单条件
   
      
   
       
   
  从多条件中选择一个
   
   
       
   
  choose (when, otherwise):选择，类似于Java中的switch语句
   
   
       
   
    <select id="selectByConditionSingle" resultMap="brandResultMap">
        select *
        from tb_brand
        where
        <choose> <!--类似于switch-->
        <when test="status != null"><!--类似于case-->
       		 status = #{status}
        </when>
        <when test="companyName != null and companyName !="">
            company_name like #{companyName}
        
        != null and brandName !=" ">
            brand_name like #{brandName}
        </when>
        <otherwise> <!--类似于default-->
        	1 =1
        </otherwise>
        </choose>
    </select>
   
   
      
   
  添加
   
      
   
       
   
  编写接口方法：Mapper接口 void add(Brand brand)
   
        
   
         
  参数:除了id之外的所有数据
   
         
  结果: void
   
        
   
   
       
   
  编写SQL语句：SQL映射文件
   
  <insert id="add">
  	insert into tb_brand (brand_name, company_name, ordered, description, status)
  	values ({brandName},#{companyName},#{ordered},#{description},#{status});
  </insert>
   
   
       
   
  执行方法，测试
   
        
   
         
  MyBatis事务: 
          
   
           
  openSession():默认开启事务，进行增删改操作后需要使用sqlSession.commit(;手动提交事务
   
           
  openSession(true):可以设置为自动提交事务(关闭事务)
   
          
   
   
        
   
   
      
   
   
    
   
    
  添加——主键返回
   
    
   
     
  在数据添加成功后，需要获取插入数据库数据的主键的值 
      
   
       
  比如：添加订单和订单项 
        
   
         
  添加订单
   
         
  添加订单项，订单项中需要设置所属订单的id
   
         
  useGeneratedKeys="true" keyProperty="id"
   
        
   
   
      
   
   
    
   
    
  <insert id="addOrder" useGeneratedKeys="true" keyProperty="id">
      insert into tb_order (payment,payment_type,status)
      values (#{payment},#{paymentType},#{status});
  </insert>
   
    
  <insert id="addOrderltem" >
      insert into tb_order_item (goods_name, goods_price, count,order_id)
      values (#{goodsName},#{goodsPrice},#{count,t#{orderld});
  </insert>
   
    
  修改
   
    
   
     
   
  修改全部字段
   
      
   
       
   
  编写接口方法: Mapper接口
   
        
   
         
  void update(Brand brand);
   
        
   
   
       
   
  参数:所有数据
   
   
       
   
  结果: void
   
   
       
   
  编写SQL语句:SQL映射文件
   
        
   
         
   
  <update id="update">update tb_brand
      set brand_name = #{brandName},
      company_name = #{companyName},ordered = #{ordered},
      description = #{description},status = #{status}
      where id = #{id};
  </update>
   
   
        
   
   
       
   
  执行方法，测试
   
   
      
   
   
     
   
  修改动态字段
   
      
   
       
  编写接口方法: Mapper接口
   
      
   
      
   
       
  参数:部分数据，封装到对象中
   
       
  结果: void
   
      
   
      
   
       
   
  编写SQL语句: SQL映射文件
   
   
       
   
  执行方法，测试
   
  <update id="update">
  	update tb_brand
  	<set>
      <if test="brandName != null and brandName !=" ">
      	brand_name = #{brandName},
      
      != null and companyName !="">
      	company_name = #{companyName},
      </if>
      <if test="ordered != null">
      	ordered = #{ordered},
      <lif>
      <if test="description != null and description !="">
      	description = #{description},
      
      status != null">
      	status = #{status}
      <lif>
      </set>
      where id = #{id};
  </update>
   
   
      
   
   
    
   
    
  删除
   
    
   
     
   
  删除一个
   
      
   
       
   
  编写接口方法: Mapper
   
        
   
         
  接口参数: id
   
         
  结果: void
   
         
  void deleteByld(int id);
   
        
   
   
       
   
  编写SQL语句:SQL映射文件
   
        
   
         
   
  <delete id="deleteByld">
  	delete from tb_brand where id = #{id}
  </delete>
   
   
        
   
   
       
   
  执行方法，测试
   
   
      
   
   
     
   
  批量删除
   
      
   
       
   
  编写接口方法: Mapper接口
   
        
   
         
  参数: id数组
   
         
  结果: void
   
         
  void deleteBylds(@Param("ids") int[]ids);
   
        
   
   
       
   
  编写SQL语句: SQL映射文件
   
        
   
         
   
  <delete id="deleteBylds">
  	delete from tb_brand
  	where id in (?,?,?)
  </delete>
   
   
         
   
  mybatis会将数组参数，封装为一个Map集合。
   
          
   
           
  *默认: array =数组
   
           
  *使用@Param注解改变map集合的默认key的名称
   
          
   
   
         
   
  <delete id="deleteBylds">
  	delete from tb_brand
  	where id in
      <foreach collection="ids" item="id" separator="," open="(" close=")">
     		#{id}
      </foreach>
  </delete>
   
   
        
   
   
       
   
  执行方法，测试
   
   
      
   
   
    
   
    
  参数传递
   
    
   
     
   
  MyBatis 接口方法中可以接收各种各样的参数，MyBatis底层对于这些参数进行不同的封装处理方式
   
      
   
       
   
  单个参数
   
        
   
         
  POJO类型：
   
         
  Map集合：
   
         
  Collection：
   
         
  List：
   
         
  Array
   
         
  其他类型：
   
        
   
   
       
   
  多个参数:封装为Map集合
   
        
   
         
   
  map.put( " arg0"，参数值1)
  map.put( " param1"，参数值1)
  map.put( "param2"，参数值2)
  map.put( "agr1"，参数值2)
   
   
         
   
  User select(@Param("username") String username,@Param("Mpassword")String password);
   
   
         
   
  <select id="select" resultType="user">
      select *
      from tb_user
      where
      username = #{username}and password = #{password};
  </select>
   
   
        
   
   
       
   
  MyBatis提供了ParamNameResolver类来进行参数封装
   
   
       
   
      
   
   
    
   
    
  
                              
                          
                      
                      
                      
  
                      
                      
                      
  
                  
                  
  
                      
  
                          
                          
  
                              
   
                          
                          
                          
  
                              
  
                          
                          
                          
  
                              
  
                          
                      
                  
              
          
      
      
  
          
  你可能感兴趣的:(java,java,开发语言,servlet)
          
  
              
  
                  
  
                      
  Long类型前后端数据不一致
                          igotyback
  前端
                          
  响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
                      
                      
  LocalDateTime 转 String
                          igotyback
  java开发语言
                          
  importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
                      
                      
  Linux下QT开发的动态库界面弹出操作（SDL2）
                          13jjyao
  QT类qt开发语言sdl2linux
                          
  需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
                      
                      
  DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                          STU学生网页设计
  网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                          
  ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
                      
                      
  【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                          若博豆
  java算法华为javascript
                          
  华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
                      
                      
  关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                          二挡起步
  web前端期末大作业javascripthtmlcss旅游风景
                          
  ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
                      
                      
  HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                          二挡起步
  web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                          
  Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
                      
                      
  node.js学习
                          小猿L
  node.jsnode.js学习vim
                          
  node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
                      
                      
  Java 重写(Override)与重载(Overload)
                          叨唧唧的
  
                          
  Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
                      
                      
  简单了解 JVM
                          记得开心一点啊
  jvm
                          
  目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
                      
                      
  1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                          Energet!c
  开发语言
                          
  1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
                      
                      
  Java企业面试题3
                          马龙强_
  java
                          
  1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
                      
                      
  JVM、JRE和 JDK：理解Java开发的三大核心组件
                          Y雨何时停T
  Javajava
                          
  Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
                      
                      
  Java面试题精选：消息队列(二)
                          芒果不是芒
  Java面试题精选javakafka
                          
  一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
                      
                      
  白骑士的Java教学基础篇 2.5 控制流语句
                          白骑士所长
  Java教学java开发语言
                          
  欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
                      
                      
  python语法——三目运算符
                          HappyRocking
  pythonpython三目运算符
                          
  在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
                      
                      
  ArrayList 源码解析
                          程序猿进阶
  Java基础ArrayListListjava面试性能优化架构设计idea
                          
  ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
                      
                      
  Java爬虫框架（一）--架构设计
                          狼图腾-狼之传说
  java框架java任务html解析器存储电子商务
                          
  一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
                      
                      
  Java：爬虫框架
                          dingcho
  Javajava爬虫
                          
  一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
                      
                      
  python怎么将png转为tif_png转tif
                          weixin_39977276
  
                          
  发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
                      
                      
  JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                          跳房子的前端
  前端面试javascript开发语言ecmascript
                          
  在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
                      
                      
  JAVA·一个简单的登录窗口
                          MortalTom
  java开发语言学习
                          
  文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
                      
                      
  WebMagic：强大的Java爬虫框架解析与实战
                          Aaron_945
  Javajava爬虫开发语言
                          
  文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
                      
                      
  博客网站制作教程
                          2401_85194651
  javamaven
                          
  首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
                      
                      
  00. 这里整理了最全的爬虫框架（Java + Python）
                          有一只柴犬
  爬虫系列爬虫javapython
                          
  目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
                      
                      
  JAVA学习笔记之23种设计模式学习
                          victorfreedom
  Java技术设计模式androidjava常用设计模式
                          
  博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
                      
                      
  JavaScript `Map` 和 `WeakMap`详细解释
                          跳房子的前端
  JavaScript原生方法javascript前端开发语言
                          
  在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
                      
                      
  切换淘宝最新npm镜像源是
                          hai40587
  npm前端node.js
                          
  切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
                      
                      
  【Java】已解决：java.util.concurrent.CompletionException
                          屿小夏
  java开发语言
                          
  文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
                      
                      
  设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
                          ok!ko
  设计模式设计模式建造者模式java
                          
  文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
                      
                                  
  如何用ruby来写hadoop的mapreduce并生成jar包
                                      wudixiaotie
  mapreduce
                                      
  ruby来写hadoop的mapreduce，我用的方法是rubydoop。怎么配置环境呢： 
  1.安装rvm： 
      不说了 网上有 
  2.安装ruby： 
      由于我以前是做ruby的，所以习惯性的先安装了ruby，起码调试起来比jruby快多了。 
  3.安装jruby： 
      rvm install jruby然后等待安
                                  
                                  
  java编程思想 -- 访问控制权限
                                      百合不是茶
  java访问控制权限单例模式
                                      
  访问权限是java中一个比较中要的知识点,它规定者什么方法可以访问,什么不可以访问 
    
  一:包访问权限; 
    
  自定义包: 
  package com.wj.control;
  //包
  public class Demo {
    //定义一个无参的方法
  	public void DemoPackage(){
  		System.out.println("调用
                                  
                                  
  [生物与医学]请审慎食用小龙虾
                                      comsci
  生物
                                      
   
       现在的餐馆里面出售的小龙虾,有一些是在野外捕捉的,这些小龙虾身体里面可能带有某些病毒和细菌,人食用以后可能会导致一些疾病,严重的甚至会死亡..... 
   
       所以,参加聚餐的时候,最好不要点小龙虾...就吃养殖的猪肉,牛肉,羊肉和鱼,等动物蛋白质 
      
                                  
                                  
  org.apache.jasper.JasperException: Unable to compile class for JSP:
                                      商人shang
  maven2.2jdk1.8
                                      
  环境： jdk1.8    maven  tomcat7-maven-plugin  2.0 
  原因： tomcat7-maven-plugin  2.0 不知吃 jdk 1.8，换成 tomcat7-maven-plugin  2.2就行，即 
    
    
  <plugin>
  				
                                  
                                  
  你的垃圾你处理掉了吗?GC
                                      oloz
  GC
                                      
  前序:本人菜鸟，此文研究学习来自网络，各位牛牛多指教　 
   
   
   
  1.垃圾收集算法的核心思想 
  　　Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用(引用)的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽，以及不恰当的内存释放所造成的内存非法引用。 
  　　垃圾收集算法的核心思想是：对虚拟机可用内存空间，即堆空间中的对象进行识别
                                  
                                  
  shiro 和 SESSSION
                                      杨白白
  shiro
                                      
  shiro 在web项目里默认使用的是web容器提供的session，也就是说shiro使用的session是web容器产生的，并不是自己产生的，在用于非web环境时可用其他来源代替。在web工程启动的时候它就和容器绑定在了一起，这是通过web.xml里面的shiroFilter实现的。通过session.getSession()方法会在浏览器cokkice产生JESSIONID，当关闭浏览器，此
                                  
                                  
  移动互联网终端 淘宝客如何实现盈利
                                      小桔子
  移動客戶端淘客淘寶App
                                      
         2012年淘宝联盟平台为站长和淘宝客带来的分成收入突破30亿元，同比增长100%。而来自移动端的分成达1亿元，其中美丽说、蘑菇街、果库、口袋购物等App运营商分成近5000万元。 可以看出，虽然目前阶段PC端对于淘客而言仍旧是盈利的大头，但移动端已经呈现出爆发之势。而且这个势头将随着智能终端(手机，平板)的加速普及而更加迅猛
                                  
                                  
  wordpress小工具制作
                                      aichenglong
  wordpress小工具
                                      
  wordpress 使用侧边栏的小工具，很方便调整页面结构 
  小工具的制作过程 
  1 在自己的主题文件中新建一个文件夹(如widget)，在文件夹中创建一个php(AWP_posts-category.php) 
  小工具是一个类,想侧边栏一样，还得使用代码注册，他才可以再后台使用，基本的代码一层不变 
  <?php 
   class AWP_Post_Category extends WP_Wi
                                  
                                  
  JS微信分享
                                      AILIKES
  js
                                      
  // 所有功能必须包含在 WeixinApi.ready 中进行 
     WeixinApi.ready(function(Api) { 
         // 微信分享的数据 
             var wxData = { 
        &nb
                                  
                                  
  封装探讨
                                      百合不是茶
  JAVA面向对象 封装
                                      
  //封装   属性 方法 将某些东西包装在一起，通过创建对象或使用静态的方法来调用，称为封装；封装其实就是有选择性地公开或隐藏某些信息，它解决了数据的安全性问题，增加代码的可读性和可维护性 
    
  在 Aname类中申明三个属性，将其封装在一个类中：通过对象来调用 
    
  例如   1： 
  	//属性 将其设为私有
  	姓名 name 可以公开
  
                                  
                                  
  jquery radio/checkbox change事件不能触发的问题
                                      bijian1013
  JavaScriptjquery
                                      
  我想让radio来控制当前我选择的是机动车还是特种车，如下所示：  
  <html> 
  <head> 
  <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js" type="text/javascript"><
                                  
                                  
  AngularJS中安全性措施
                                      bijian1013
  JavaScriptAngularJS安全性XSRFJSON漏洞
                                      
          在使用web应用中，安全性是应该首要考虑的一个问题。AngularJS提供了一些辅助机制，用来防护来自两个常见攻击方向的网络攻击。 
  一.JSON漏洞 
          当使用一个GET请求获取JSON数组信息的时候（尤其是当这一信息非常敏感，
                                  
                                  
  [Maven学习笔记九]Maven发布web项目
                                      bit1129
  maven
                                      
  基于Maven的web项目的标准项目结构 
  user-project 
      user-core 
      user-service 
      user-web 
         src 
       
                                  
                                  
  【Hive七】Hive用户自定义聚合函数(UDAF)
                                      bit1129
  hive
                                      
  用户自定义聚合函数，用户提供的多个入参通过聚合计算(求和、求最大值、求最小值)得到一个聚合计算结果的函数。 
  问题：UDF也可以提供输入多个参数然后输出一个结果的运算，比如加法运算add(3，5)，add这个UDF需要实现UDF的evaluate方法,那么UDF和UDAF的实质分别究竟是什么？ 
    
  Double evaluate(Double a, Double b) 
   
                                  
                                  
  通过 nginx-lua 给 Nginx 增加 OAuth 支持
                                      ronin47
  
                                      
  前言：我们使用Nginx的Lua中间件建立了OAuth2认证和授权层。如果你也有此打算，阅读下面的文档，实现自动化并获得收益。SeatGeek 在过去几年中取得了发展，我们已经积累了不少针对各种任务的不同管理接口。我们通常为新的展示需求创建新模块，比如我们自己的博客、图表等。我们还定期开发内部工具来处理诸如部署、可视化操作及事件处理等事务。在处理这些事务中，我们使用了几个不同的接口来认证： 
  &n
                                  
                                  
  利用tomcat-redis-session-manager做session同步时自定义类对象属性保存不上的解决方法
                                      bsr1983
  session
                                      
  在利用tomcat-redis-session-manager做session同步时，遇到了在session保存一个自定义对象时，修改该对象中的某个属性，session未进行序列化，属性没有被存储到redis中。   在 tomcat-redis-session-manager的github上有如下说明：   Session Change Tracking 
  As noted in the &qu
                                  
                                  
  《代码大全》表驱动法-Table Driven Approach-1
                                      bylijinnan
  java算法
                                      
  关于Table Driven Approach的一篇非常好的文章： 
   
  http://www.codeproject.com/Articles/42732/Table-driven-Approach 
   
   
  package com.ljn.base;
  
  import java.util.Random;
  
  public class TableDriven {
  
      public 
                                  
                                  
  Sybase封锁原理
                                      chicony
  Sybase
                                      
         昨天在操作Sybase IQ12.7时意外操作造成了数据库表锁定，不能删除被锁定表数据也不能往其中写入数据。由于着急往该表抽入数据，因此立马着手解决该表的解锁问题。     无奈此前没有接触过Sybase IQ12.7这套数据库产品，加之当时已属于下班时间无法求助于支持人员支持，因此只有借助搜索引擎强大的
                                  
                                  
  java异常处理机制
                                      CrazyMizzz
  java
                                      
  java异常关键字有以下几个，分别为 try catch final throw throws 
  他们的定义分别为 
  try：    Opening exception-handling statement. 
  catch：  Captures the exception. 
  finally： Runs its code before terminating
                                  
                                  
  hive 数据插入DML语法汇总
                                      daizj
  hiveDML数据插入
                                      
  Hive的数据插入DML语法汇总1、Loading files into tables语法：1) LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename [PARTITION (partcol1=val1, partcol2=val2 ...)]解释：1)、上面命令执行环境为hive客户端环境下： hive>l
                                  
                                  
  工厂设计模式
                                      dcj3sjt126com
  设计模式
                                      
    使用设计模式是促进最佳实践和良好设计的好办法。设计模式可以提供针对常见的编程问题的灵活的解决方案。  工厂模式 
  工厂模式（Factory）允许你在代码执行时实例化对象。它之所以被称为工厂模式是因为它负责“生产”对象。工厂方法的参数是你要生成的对象对应的类名称。  
  Example #1 调用工厂方法（带参数）   
  <?phpclass Example{ 
                                  
                                  
  mysql字符串查找函数
                                      dcj3sjt126com
  mysql
                                      
    
  FIND_IN_SET(str,strlist) 
  假如字符串str 在由N 子链组成的字符串列表strlist 中，则返回值的范围在1到 N 之间。一个字符串列表就是一个由一些被‘,’符号分开的自链组成的字符串。如果第一个参数是一个常数字符串，而第二个是type SET列，则   FIND_IN_SET() 函数被优化，使用比特计算。如果str不在strlist 或st
                                  
                                  
  jvm内存管理
                                      easterfly
  jvm
                                      
  一、JVM堆内存的划分 
   分为年轻代和年老代。年轻代又分为三部分：一个eden,两个survivor。 
   工作过程是这样的：e区空间满了后，执行minor gc，存活下来的对象放入s0, 对s0仍会进行minor gc，存活下来的的对象放入s1中，对s1同样执行minor gc，依旧存活的对象就放入年老代中； 
   年老代满了之后会执行major gc，这个是stop the word模式，执行
                                  
                                  
  CentOS-6.3安装配置JDK-8
                                      gengzg
  centos
                                      
  JAVA_HOME=/usr/java/jdk1.8.0_45
  JRE_HOME=/usr/java/jdk1.8.0_45/jre
  PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin
  CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib
  export JAVA_HOME
                                  
                                  
  【转】关于web路径的获取方法
                                      huangyc1210
  Web路径
                                      
  假定你的web application 名称为news,你在浏览器中输入请求路径：  http://localhost:8080/news/main/list.jsp  则执行下面向行代码后打印出如下结果：  1、 System.out.println(request.getContextPath()); //可返回站点的根路径。也就是项
                                  
                                  
  php里获取第一个中文首字母并排序
                                      远去的渡口
  数据结构PHP
                                      
  很久没来更新博客了，还是觉得工作需要多总结的好。今天来更新一个自己认为比较有成就的问题吧。 最近在做储值结算，需求里结算首页需要按门店的首字母A-Z排序。我的数据结构原本是这样的： 
  Array
  (
      [0] => Array
          (
              [sid] => 2885842
              [recetcstoredpay] =&g
                                  
                                  
  java内部类
                                      hm4123660
  java内部类匿名内部类成员内部类方法内部类
                                      
       　在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。内部类可以间接解决多继承问题,可以使用内部类继承一个类，外部类继承一个类，实现多继承。 
       &nb
                                  
                                  
  Caused by: java.lang.IncompatibleClassChangeError: class org.hibernate.cfg.Exten
                                      zhb8015
  
                                      
  maven pom.xml关于hibernate的配置和异常信息如下，查了好多资料，问题还是没有解决。只知道是包冲突，就是不知道是哪个包....遇到这个问题的分享下是怎么解决的。。 
    
  maven pom: 
    
  		<dependency>
  			<groupId>org.hibernate</groupId>
  			<ar
                                  
                                  
  Spark 性能相关参数配置详解－任务调度篇
                                      Stark_Summer
  sparkcachecpu任务调度yarn
                                      
  随着Spark的逐渐成熟完善, 越来越多的可配置参数被添加到Spark中来, 本文试图通过阐述这其中部分参数的工作原理和配置思路, 和大家一起探讨一下如何根据实际场合对Spark进行配置优化。 
    
  由于篇幅较长，所以在这里分篇组织，如果要看最新完整的网页版内容，可以戳这里：http://spark-config.readthedocs.org/，主要是便
                                  
                                  
  css3滤镜
                                      wangkeheng
  htmlcss
                                      
  经常看到一些网站的底部有一些灰色的图标，鼠标移入的时候会变亮，开始以为是js操作src或者bg呢，搜索了一下，发现了一个更好的方法：通过css3的滤镜方法。 
   
  html代码： 
   
  <a href='' class='icon'><img src='utv.jpg' /></a> 
  css代码： 
   
  .icon{-webkit-filter: graysc
                                  
                  
              
          
      
  
  
      
  
          
  
              按字母分类：
              ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
          
      
  
  
      
  
          
  
              首页 -
              关于我们 -
              站内搜索 -
              Sitemap -
              侵权投诉
          
          
  版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.