คำถามติดแท็ก java

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้นี้ ปิดให้บริการใน6 ปีที่ผ่านมา ฉันเคยได้ยินเรื่องดี ๆ เกี่ยวกับ JSF มาหลายครั้งแล้ว แต่เท่าที่ฉันรู้ว่าผู้คนเคยบ่นอย่างจริงจังกับเทคโนโลยีนี้มาแล้วในอดีตไม่ทราบว่าสถานการณ์ดีขึ้นมากเพียงใด เรากำลังพิจารณา JSF เป็นเทคโนโลยีที่น่าจะเป็นสำหรับโครงการเครือข่ายสังคม แต่เราไม่ทราบถึงคะแนนประสิทธิภาพของ JSF ไม่ว่าเราจะเจอเว็บไซต์ประสิทธิภาพสูงที่มีการใช้ JSF จริงๆ ผู้คนบ่นเกี่ยวกับปัญหาความสามารถในการขยายขีดความสามารถ เรายังไม่แน่ใจว่าถ้าเราทำสิ่งที่ถูกต้องโดยเลือก jsf และอยากจะได้ยินจากคุณเกี่ยวกับเรื่องนี้และนำข้อมูลของคุณมาพิจารณา เป็นไปได้หรือไม่ที่จะกำหนดค่า JSF เพื่อสนองความต้องการประสิทธิภาพสูงของบริการเครือข่ายสังคม นอกจากนี้จนถึงระดับที่เป็นไปได้ที่จะอยู่รอดด้วยปัญหาปัจจุบันใน JSF มันมีปัญหาอะไรกันแน่? ฉันไม่ได้ กังวลเกี่ยวกับความซับซ้อนของการพัฒนากับ JSF สิ่งที่คนอื่นมักจะบ่นเพราะตามประสบการณ์ส่วนตัวของฉันฉันเชื่อว่ามันไม่เป็นความจริงเลย แต่ฉันกังวลเกี่ยวกับประสิทธิภาพและปัญหาการปรับขนาดได้ และโปรดอย่าเพียง แต่ใช้ผิดกฎเกี่ยวกับปัญหาเก่าที่เชื่อมโยงกับรุ่นก่อนหน้า ฉันแค่สนใจเกี่ยวกับสถานะปัจจุบันสิ่งที่เคยเป็นมาในอดีต

16 java  web-development  web-applications  web-framework 

ล็อคแล้ว คำถามและคำตอบของคำถามนี้ถูกล็อคเนื่องจากคำถามอยู่นอกหัวข้อ แต่มีความสำคัญทางประวัติศาสตร์ ขณะนี้ไม่ยอมรับคำตอบหรือการโต้ตอบใหม่ อะไรคือความแตกต่างระหว่าง "การเขียน JRE เฉพาะสำหรับแต่ละแพลตฟอร์ม" สำหรับนักพัฒนา Java และ "การเขียนคอมไพเลอร์ C ++ สำหรับแต่ละแพลตฟอร์ม" สำหรับ C ++

16 java  c++  portability 

ฉันเป็นนักพัฒนา Java มานานและในที่สุดหลังจากวิชาเอกฉันมีเวลาศึกษาอย่างเหมาะสมเพื่อทำการสอบรับรอง ... สิ่งหนึ่งที่ทำให้ฉันรำคาญอยู่เสมอคือ String เป็น "ขั้นสุดท้าย" ฉันเข้าใจเมื่ออ่านเกี่ยวกับปัญหาด้านความปลอดภัยและสิ่งที่เกี่ยวข้อง ... แต่จริงๆแล้วทุกคนมีตัวอย่างที่แท้จริงของเรื่องนี้หรือไม่? ตัวอย่างเช่นจะเกิดอะไรขึ้นหาก String ไม่เป็นที่สิ้นสุด มันไม่ได้อยู่ในรูบี ฉันไม่เคยได้ยินเรื่องร้องเรียนใด ๆ ที่มาจากชุมชน Ruby ... และฉันรู้ว่า StringUtils และคลาสที่เกี่ยวข้องที่คุณต้องใช้เองหรือค้นหาผ่านเว็บเพื่อใช้พฤติกรรมนั้น (โค้ด 4 บรรทัด) คุณ ยินดีที่จะ

16 java  security 

ล็อคแล้ว คำถามและคำตอบของคำถามนี้ถูกล็อคเนื่องจากคำถามอยู่นอกหัวข้อ แต่มีความสำคัญทางประวัติศาสตร์ ขณะนี้ไม่ยอมรับคำตอบหรือการโต้ตอบใหม่ ฉันเป็นภาษาสกาล่าโดยสิ้นเชิง ... ฉันยังคงดิ้นรนกับเหตุผลที่ว่า บริษัท ใดควรเปลี่ยนจากชวาเป็นสคาลา Scala เป็นเพียงน้ำตาล syntatic ที่ด้านบนของ JVM หรือมีการปรับปรุงพื้นฐานใน Scala มากกว่า Java ที่จะปรับปรุงการใช้งานจริงหรือไม่?

16 java  scala 

คุณคิดว่าการเขียนโค้ดตายมีประโยชน์หรือไม่? บางคนบอกว่า "ถ้าคุณมี 2 ตรรกะในการดำเนินการบางอย่างแล้วแทนที่จะทำให้ความเห็นรหัสตรรกะอื่น ๆ หรือลบรหัสทำให้มันเป็นรหัสตายเพราะมันจะไม่ส่งผลกระทบต่อการดำเนินงาน" ตัวอย่าง:- if(true){ // logic - 1 } else { // logic - 2 // dead code } จริงป้ะ? ฉันมักจะไม่เขียนโค้ดที่ตายแล้วแทนที่จะลบตรรกะที่สอง

16 java 

อยู่ที่ไหนสักแห่งที่ฉันเห็นว่าพูดจาโผงผางกับ java / javac ที่ถูกกล่าวหาว่าใช้การผสมผสานระหว่าง Windows และ Unix style java -classpath ... -ea ... Something IMHO มันไม่มีการผสมผสานมันก็เหมือนfindงานเหมือนกันใช่ไหม AFAIK ตาม POSIX ไวยากรณ์ควรเป็นเช่นนั้น java --classpath ... --ea ... Something และ-abcdefจะหมายถึงการระบุ 6 ตัวเลือกสั้น ๆ ในครั้งเดียว ฉันสงสัยว่าเวอร์ชันใดที่นำไปสู่การพิมพ์น้อยลงและมีข้อผิดพลาดน้อยลง ฉันกำลังเขียนโปรแกรมอรรถประโยชน์ขนาดเล็กใน Java และไม่ว่าในกรณีใดฉันจะใช้รูปแบบ Windows /a /bเนื่องจากฉันสนใจ Unix เป็นหลัก ฉันควรเลือกรูปแบบใด

16 java  unix  command-line 

ปิด คำถามนี้ต้องการรายละเอียดหรือความคมชัด ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ เพิ่มรายละเอียดและชี้แจงปัญหาโดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ฉันใหม่กับ Java และต้องการเข้าใจความแตกต่างระหว่างตัวแปรคลาสและตัวแปรอินสแตนซ์ ตัวอย่างเช่น: class Bicycle { static int cadence = 0; int speed = 0; int gear = 1; } ตัวแปรอินสแตนซ์และตัวแปรคลาสแตกต่างจากกันอย่างไร ตัวแปรใดที่นี่คือตัวแปรคลาสและตัวแปรอินสแตนซ์ใด สิ่งนี้มีผลต่อขอบเขตอย่างไร

16 java  class  object  instance 

ฉันเพิ่งเจอโครงสร้าง Java ฉันไม่เคยเห็นมาก่อนและสงสัยว่าฉันควรใช้ มันดูเหมือนว่าจะถูกเรียกว่าการเริ่มต้นบล็อก public class Test { public Test() { /* first constructor */ } public Test(String s) { /* second constructor */ } // Non-static initializer block - copied into every constructor: { doStuff(); } } บล็อกรหัสจะถูกคัดลอกลงในตัวสร้างแต่ละตัวเช่นถ้าคุณมีตัวสร้างหลายตัวคุณไม่จำเป็นต้องเขียนรหัสใหม่ อย่างไรก็ตามฉันเห็นข้อเสียเปรียบหลักสามประการที่ใช้ไวยากรณ์นี้: เป็นหนึ่งในไม่กี่กรณีใน Java ที่ลำดับของรหัสของคุณมีความสำคัญเนื่องจากคุณสามารถกำหนดบล็อคโค้ดหลาย ๆ อันและจะถูกดำเนินการตามลำดับที่เขียน ดูเหมือนว่าเป็นอันตรายกับฉันเพียงแค่เปลี่ยนลำดับของการบล็อกรหัสจริง ๆ แล้วจะเปลี่ยนรหัส ฉันไม่เห็นประโยชน์ใด ๆ …

16 java 

เมื่อฉันมีข้อมูลจำนวนมากที่ต้องได้รับการตรวจสอบความถูกต้องฉันควรสร้างคลาสใหม่เพื่อวัตถุประสงค์ในการตรวจสอบความถูกต้องเพียงอย่างเดียวหรือฉันควรจะใช้การตรวจสอบความถูกต้องด้วยวิธีการหรือไม่ ตัวอย่างเฉพาะของฉันพิจารณาแม่แบบทัวร์นาเมนต์และคลาสของเหตุการณ์ / หมวดหมู่: TournamentและEventซึ่งเป็นตัวอย่างของการแข่งขันกีฬาและแต่ละทัวร์นาเมนต์มีหนึ่งหรือหลายประเภท มีทุกสิ่งที่จะตรวจสอบในชั้นเรียนเหล่านี้: ผู้เล่นควรว่างเปล่า, ไม่ซ้ำกัน, จำนวนการแข่งขันที่ผู้เล่นแต่ละคนควรเล่น, จำนวนผู้เล่นแต่ละคนมีการแข่งขัน, การแข่งขันที่กำหนดไว้ล่วงหน้าและอื่น ๆ กฎที่ซับซ้อน นอกจากนี้ยังมีบางส่วนที่ฉันต้องการตรวจสอบโดยรวมเช่นวิธีที่ชั้นเรียนทำงานร่วมกัน ตัวอย่างเช่นการตรวจสอบความถูกต้องแบบรวมPlayerสามารถทำได้ แต่ถ้าเหตุการณ์มีผู้เล่นคนเดียวกันสองครั้งนั่นเป็นข้อผิดพลาดในการตรวจสอบความถูกต้อง แล้วเรื่องนี้ล่ะ: ฉันลืมเกี่ยวกับการตรวจสอบล่วงหน้าอย่างแน่นอนเมื่อใช้ setters ของคลาสโมเดลของฉันและวิธีการที่คล้ายกันเพื่อเพิ่มข้อมูลและแทนที่จะให้คลาสการตรวจสอบจัดการแทน ดังนั้นเราจะมีบางสิ่งที่คล้ายEventValidatorกับการEventเป็นสมาชิกและvalidate()วิธีการที่ตรวจสอบความถูกต้องของวัตถุทั้งหมดรวมถึงวิธีเอกพจน์เพื่อตรวจสอบกฎของสมาชิกทั้งหมด จากนั้นก่อนที่จะสร้างอินสแตนซ์ของวัตถุที่ตรวจสอบได้ฉันจะดำเนินการตรวจสอบเพื่อป้องกันค่าที่ผิดกฎหมาย การออกแบบของฉันถูกต้องหรือไม่ ฉันควรทำอะไรที่แตกต่างออกไปไหม นอกจากนี้ฉันควรใช้บูลีนวิธีการตรวจสอบกลับ? หรือเพียงแค่โยนข้อยกเว้นถ้าการตรวจสอบล้มเหลว? ดูเหมือนว่าสำหรับฉันตัวเลือกที่ดีที่สุดคือวิธีการส่งคืนบูลีนและส่งข้อยกเว้นเมื่อวัตถุนั้นเป็นอินสแตนซ์ตัวอย่างเช่น: public Event() { EventValidator eventValidator = new EventValidator(this); if (!eventValidator.validate()) { // show error messages with methods defined in the validator throw new …

16 java  design  data  validation 

สมมติว่าเรามีคลาส Python ดังต่อไปนี้ (ปัญหามีอยู่ใน Java เช่นเดียวกับequalsและhashCode) class Temperature: def __init__(self, degrees): self.degrees = degrees ที่degreesเป็นอุณหภูมิเคลวินเป็นลอยที่ ตอนนี้ฉันต้องการที่จะใช้การทดสอบความเท่าเทียมกันและ hashing Temperatureในทางที่ เปรียบเทียบลอยขึ้นกับความแตกต่าง epsilon แทนการทดสอบความเท่าเทียมกันโดยตรง และได้รับเกียรตินิยมสัญญาว่าหมายถึงa == bhash(a) == hash(b) def __eq__(self, other): return abs(self.degrees - other.degrees) < EPSILON def __hash__(self): return # What goes here? เอกสาร Python พูดถึงตัวเลขการแฮชเล็กน้อยเพื่อให้แน่ใจว่าhash(2) == hash(2.0)นี่ไม่ใช่ปัญหาเดียวกัน ฉันยังอยู่ในเส้นทางที่ถูกต้องหรือไม่? และถ้าเป็นเช่นนั้นวิธีมาตรฐานในการใช้การแฮชในสถานการณ์นี้คืออะไร? ปรับปรุง …

15 java  python  hashing  floating-point 

ขณะนี้ฉันกำลังใช้ตัวบันทึกในโครงการของฉันด้วยวิธีต่อไปนี้: private static final Logger LOGGER; static{ LOGGER = logger.getLogger(); } ฉันได้รับรหัสตรวจสอบสำหรับการใช้บล็อกแบบคงที่เพื่อเริ่มต้นตัวแปรตัวบันทึก ฉันบอกให้ intialize ตัวแปร logger ในงบการประกาศตัวเอง private static final Logger LOGGER = Logger.getLogger(); ฉันพยายามคิดว่ามันจะสร้างความแตกต่างอะไรถ้าฉันไม่เริ่มต้นมันในบล็อกแบบคงที่ ฉันต้องการที่จะรู้ว่านี่คือการปฏิบัติ

15 java 

ตัวดำเนินการเพิ่มของคลาส set ส่งคืนบูลีนซึ่งเป็นจริงหากองค์ประกอบ (ซึ่งจะถูกเพิ่ม) ยังไม่มีอยู่และเป็นเท็จ กำลังเขียน if (set.add(entry)) { //do some more stuff } ถือว่าเป็นสไตล์ที่ดีในแง่ของการเขียนโค้ดที่สะอาด? ฉันสงสัยว่าคุณทำสองสิ่งพร้อมกัน 1) การเพิ่มองค์ประกอบและ 2) การตรวจสอบว่ามีองค์ประกอบอยู่หรือไม่

15 java  coding-style  clean-code 

หลายครั้งที่ฉันตรวจสอบตัวเองเป็นโมฆะเมื่อดึงค่าจากลำดับชั้นข้อมูลบางอย่างเพื่อหลีกเลี่ยง NullPointerExceptions ซึ่งฉันพบว่ามีแนวโน้มที่จะเกิดข้อผิดพลาดและต้องมีสำเร็จรูปจำนวนมาก ฉันได้เขียนกิจวัตรที่ง่ายมากซึ่งทำให้ฉันสามารถข้ามการตรวจสอบค่าว่างเมื่อดึงวัตถุ ... public final class NoNPE { public static <T> T get(NoNPEInterface<T> in) { try { return in.get(); } catch (NullPointerException e) { return null; } } public interface NoNPEInterface<T> { T get(); } } ฉันใช้มันแบบนี้ ... Room room = NoNPE.get(() -> country.getTown().getHouses().get(0).getLivingRoom()); ด้านบนทำให้ฉันได้รับวัตถุห้องหรือโมฆะโดยไม่ต้องตรวจสอบระดับผู้ปกครองทั้งหมด คุณคิดอย่างไรกับข้างต้น? ฉันกำลังสร้างรูปแบบที่มีปัญหาหรือไม่? มีวิธีที่ดีกว่านี้ในความคิดของคุณ?

15 java  null 

TL; DR - การใช้ไลบรารี POJO ร่วมกันระหว่างบริการต่าง ๆ เป็นเรื่องปกติไหม โดยทั่วไปเราต้องการให้การแบ่งปันระหว่างบริการ จำกัด อย่างเข้มงวดเป็นไม่ถ้าเป็นไปได้ มีการถกเถียงกันบ้างหรือไม่ว่าบริการที่ใช้ข้อมูลร่วมกันนั้นควรจัดให้มีห้องสมุดลูกค้าให้ลูกค้าใช้หรือไม่ โดยทั่วไปแล้ว client-lib นั้นเป็นทางเลือกสำหรับลูกค้าของบริการที่จะใช้และสามารถใช้งาน API ได้อย่างไรก็ตามพวกเขาจะโปรดใช้ว่าจะใช้ client-lib หรือใช้ภาษาอื่นและใช้ลักษณะทั่วไปของไลบรารีและเช่นนั้น ในกรณีของฉัน - ฉันพิจารณาบริการที่สร้างวัตถุของข้อมูล สมมติว่าวัตถุนี้เป็นสัตว์เลี้ยง มันไม่ใช่เอนทิตีของฐานข้อมูล แต่เป็น POJO ที่แสดงถึงข้อมูลพื้นฐานโดยนัย POJO นี้เป็นสิ่งที่ API ได้กำหนดไว้ สมมติว่า: สัตว์เลี้ยง - อายุ, น้ำหนัก, ชื่อ, เจ้าของ, ที่อยู่, สปีชี่ ฯลฯ บริการ 1 - PetKeeper: มันจะสร้างสัตว์เลี้ยงด้วยเหตุผลใดก็ตามและเก็บข้อมูลทั้งหมดไว้และต้องอ้างอิงบริการนี้เพื่อรับสัตว์เลี้ยงหรือทำการดัดแปลงสัตว์เลี้ยงให้พูดการเปลี่ยนชื่อหรือการเปลี่ยนที่อยู่จะต้องทำผ่าน การเรียก API ไปยังบริการนี้ บริการ …

15 java  dto  microservices 

ฉันกำลังทำงานเกี่ยวกับการออกแบบแอปพลิเคชันที่ประกอบด้วยสามส่วน: เธรดเดียวที่เฝ้าดูเหตุการณ์บางอย่างที่เกิดขึ้น (การสร้างไฟล์คำขอภายนอก ฯลฯ ) เธรดผู้ปฏิบัติงาน N ที่ตอบสนองต่อเหตุการณ์เหล่านี้โดยการประมวลผล (ผู้ปฏิบัติงานแต่ละกระบวนการและใช้เหตุการณ์เดียวและการประมวลผลอาจใช้เวลาแปรผัน) คอนโทรลเลอร์ที่จัดการเธรดเหล่านั้นและจัดการข้อผิดพลาด (การรีสตาร์ทเธรดการบันทึกผลลัพธ์) แม้ว่านี่จะค่อนข้างพื้นฐานและไม่ยากที่จะนำมาใช้ แต่ฉันก็สงสัยว่ามันจะเป็นวิธีที่ "ถูกต้อง" (ในกรณีที่เป็นรูปธรรมนี้ใน Java แต่คำตอบที่เป็นนามธรรมก็สูงขึ้นเช่นกัน) กลยุทธ์ทั้งสองมาถึงใจ: ผู้สังเกตการณ์ / สังเกตได้:ผู้สังเกตการณ์จะเฝ้าสังเกตด้ายดู ในกรณีที่มีเหตุการณ์เกิดขึ้นคอนโทรลเลอร์จะได้รับแจ้งและสามารถมอบหมายงานใหม่ให้กับเธรดอิสระจากกลุ่มเธรดแคชที่ใช้ซ้ำได้ (หรือรอและแคชงานในคิว FIFO หากเธรดทั้งหมดไม่ว่างในขณะนี้) เธรดผู้ปฏิบัติงานใช้ Callable และส่งคืนผลลัพธ์ที่สำเร็จพร้อมกับผลลัพธ์ (หรือค่าบูลีน) หรือส่งคืนพร้อมข้อผิดพลาดในกรณีนี้ผู้ควบคุมอาจตัดสินใจว่าจะทำอย่างไร (ขึ้นอยู่กับลักษณะของข้อผิดพลาดที่เกิดขึ้น) ผู้ผลิต / ผู้บริโภค : เธรดการเฝ้าดูที่ใช้ร่วมกัน BlockingQueue กับตัวควบคุม (เหตุการณ์คิว) และตัวควบคุมที่ใช้ร่วมกันสองกับคนงานทั้งหมด (งานคิวและผลคิว) ในกรณีที่เกิดเหตุการณ์ด้ายเฝ้าดูทำให้วัตถุงานในคิวเหตุการณ์ คอนโทรลเลอร์ใช้งานใหม่จาก event-queue ตรวจสอบและวางไว้ใน task-queue ผู้ปฏิบัติงานแต่ละคนรองานใหม่และรับ / ใช้งานจากคิวงาน (มาก่อนได้รับก่อนจัดการโดยคิวเอง) …

15 java  architecture  concurrency  observer-pattern  producer-consumer